graphql api tested & user resolver, schema and mongo interfaces tested

models/Build.ts

@@ -0,0 +1,61 @@
+import mongoose, { Schema, Document, models } from "mongoose";
+import { Base } from "./base";
+
+const BuildIbanSchema = new Schema({
+    iban: { type: String, required: true },
+    startDate: { type: Date, required: true },
+    stopDate: { type: Date, required: true, default: new Date("2900-01-01T03:00:00+03:00") },
+    bankCode: { type: String, required: true, default: "TR0000000000000" },
+    xcomment: { type: String, required: true, default: "????" },
+});
+
+const BuildResponsibleSchema = new Schema({
+    company: { type: Schema.Types.ObjectId, ref: "Company", required: true },
+    person: { type: Schema.Types.ObjectId, ref: "Person", required: true },
+});
+
+const BuildInfoSchema = new Schema({
+    govAddressCode: { type: String, required: true },
+    buildName: { type: String, required: true },
+    buildNo: { type: String, required: true },
+    maxFloor: { type: Number, required: true },
+    undergroundFloor: { type: Number, required: true },
+    buildDate: { type: Date, required: true },
+    decisionPeriodDate: { type: Date, required: true },
+    taxNo: { type: String, required: true },
+    liftCount: { type: Number, required: true },
+    heatingSystem: { type: Boolean, required: true },
+    coolingSystem: { type: Boolean, required: true },
+    hotWaterSystem: { type: Boolean, required: true },
+    blockServiceManCount: { type: Number, required: true },
+    securityServiceManCount: { type: Number, required: true },
+    garageCount: { type: Number, required: true },
+    managementRoomId: { type: Number, required: true },
+});
+
+interface IBuildInterface extends Base, Document {
+    buildType: Schema.Types.ObjectId;
+    collectionToken: string;
+    info: typeof BuildInfoSchema;
+    site?: Schema.Types.ObjectId;
+    address?: Schema.Types.ObjectId;
+    ibans?: typeof BuildIbanSchema[];
+    areas?: Schema.Types.ObjectId[];
+    responsibles?: typeof BuildResponsibleSchema[];
+}
+
+const BuildSchema = new Schema<IBuildInterface>({
+    buildType: { type: Schema.Types.ObjectId, ref: "BuildType", required: true },
+    collectionToken: { type: String, required: true, unique: true },
+    info: { type: BuildInfoSchema, required: true },
+    site: { type: Schema.Types.ObjectId, ref: "Site", required: false },
+    address: { type: Schema.Types.ObjectId, ref: "BuildAddress", required: false },
+    areas: [{ type: Schema.Types.ObjectId, ref: "BuildArea", required: false }],
+    ibans: [{ type: BuildIbanSchema, required: false }],
+    responsibles: [{ type: BuildResponsibleSchema, required: false }],
+}, { timestamps: true });
+
+const Build = models.Build || mongoose.model<IBuildInterface>("Build", BuildSchema);
+
+export { Build };
+export type { IBuildInterface };

models/BuildAddress.ts

@@ -0,0 +1,31 @@
+import mongoose, { Schema, Document, models } from "mongoose";
+import { Base } from "./base";
+
+interface IBuildAddressInterface extends Base, Document {
+    buildNumber: string;
+    doorNumber: string;
+    floorNumber: string;
+    commentAddress: string;
+    letterAddress: string;
+    shortLetterAddress: string;
+    latitude: number;
+    longitude: number;
+    street: mongoose.Types.ObjectId;
+}
+
+const BuildAddressSchema = new Schema<IBuildAddressInterface>({
+    buildNumber: { type: String, required: true },
+    doorNumber: { type: String, required: true },
+    floorNumber: { type: String, required: true },
+    commentAddress: { type: String, required: true },
+    letterAddress: { type: String, required: true },
+    shortLetterAddress: { type: String, required: true },
+    latitude: { type: Number, required: true },
+    longitude: { type: Number, required: true },
+    street: { type: Schema.Types.ObjectId, ref: "Street", required: true },
+}, { timestamps: true });
+
+const BuildAddress = models.BuildAddress || mongoose.model<IBuildAddressInterface>("BuildAddress", BuildAddressSchema);
+
+export { BuildAddress };
+export type { IBuildAddressInterface };

models/BuildArea.ts

@@ -0,0 +1,25 @@
+import mongoose, { Schema, Document, models } from "mongoose";
+import { Base } from "./base";
+
+interface IBuildArea extends Base, Document {
+    build: mongoose.Types.ObjectId;
+    area: number;
+    size: number;
+    type: string;
+    typeToken: string;
+    description: string;
+}
+
+const BuildAreaSchema = new Schema<IBuildArea>({
+    build: { type: Schema.Types.ObjectId, ref: "Build", required: true },
+    area: { type: Number, required: true },
+    size: { type: Number, required: true },
+    type: { type: String, required: true },
+    typeToken: { type: String, required: true },
+    description: { type: String, required: true },
+}, { timestamps: true });
+
+const BuildArea = models.BuildArea || mongoose.model<IBuildArea>("BuildArea", BuildAreaSchema);
+
+export { BuildArea, BuildAreaSchema };
+export type { IBuildArea };

models/BuildParts.ts

@@ -0,0 +1,37 @@
+
+import mongoose, { Schema, Document, models } from "mongoose";
+import { Base } from "./base";
+
+interface IBuildPartsInterface extends Base, Document {
+    addressGovCode: string;
+    no: number;
+    level: number;
+    code: string;
+    grossSize: number;
+    netSize: number;
+    defaultAccessory: string;
+    humanLivability: boolean;
+    key: string;
+    directionId: Schema.Types.ObjectId;
+    typeId: Schema.Types.ObjectId;
+}
+
+const BuildPartsSchema = new Schema({
+    buildId: { type: Schema.Types.ObjectId, ref: "Build", required: true },
+    addressGovCode: { type: String, required: true },
+    no: { type: Number, required: true },
+    level: { type: Number, required: true },
+    code: { type: String, required: true },
+    grossSize: { type: Number, required: true },
+    netSize: { type: Number, required: true },
+    defaultAccessory: { type: String, required: true },
+    humanLivability: { type: Boolean, required: true },
+    key: { type: String, required: true },
+    directionId: { type: Schema.Types.ObjectId, ref: "ApiEnumDropdown", required: true },
+    typeId: { type: Schema.Types.ObjectId, ref: "ApiEnumDropdown", required: true },
+});
+
+const BuildParts = models.BuildParts || mongoose.model<IBuildPartsInterface>("BuildParts", BuildPartsSchema);
+
+export { BuildParts };
+export type { IBuildPartsInterface };

models/Company.ts

@@ -0,0 +1,7 @@
+
+
+interface ICompanyInterface {
+
+}
+
+export type { ICompanyInterface };

models/LivingSpaces.ts

@@ -0,0 +1,44 @@
+import mongoose, { Schema, Model, Document } from 'mongoose';
+import { IPerson } from './People';
+import { IBuildPartsInterface } from './BuildParts';
+import { ICompanyInterface } from './Company';
+import { Base } from './base';
+import { IUserType } from './UserTypes';
+import { randomUUID } from 'crypto';
+
+interface ILivingSpaces extends Base, Document {
+    part: mongoose.Types.ObjectId | IBuildPartsInterface;
+    company: mongoose.Types.ObjectId | ICompanyInterface;
+    person: mongoose.Types.ObjectId | IPerson;
+    userType: mongoose.Types.ObjectId | IUserType;
+}
+
+function getDynamicLivingSpaceModel(collectionToken: string): Model<ILivingSpaces> {
+    const collectionName = `LivingSpaces${collectionToken}`;
+    if (mongoose.models[collectionName]) { return mongoose.models[collectionName] as Model<ILivingSpaces> }
+    const LivingSpacesSchema = new Schema<ILivingSpaces>({
+        uuid: { type: String, required: false, unique: true, default: () => randomUUID() },
+        part: { type: Schema.Types.ObjectId, ref: "BuildParts", required: true },
+        company: { type: Schema.Types.ObjectId, ref: "Company", required: true },
+        person: { type: Schema.Types.ObjectId, ref: "Person", required: true },
+        userType: { type: Schema.Types.ObjectId, ref: "UserType", required: true },
+        expiryStarts: { type: Date, required: false, default: new Date() },
+        expiryEnds: { type: Date, required: false, default: new Date("2900-01-01T03:00:00+03:00") },
+        isConfirmed: { type: Boolean, required: false, default: false },
+        deleted: { type: Boolean, required: false, default: false },
+        active: { type: Boolean, required: false, default: true },
+        crypUuId: { type: String, required: false },
+        createdCredentialsToken: { type: String, required: false },
+        updatedCredentialsToken: { type: String, required: false },
+        confirmedCredentialsToken: { type: String, required: false },
+        isNotificationSend: { type: Boolean, required: false, default: false },
+        isEmailSend: { type: Boolean, required: false, default: false },
+        refInt: { type: Number, required: false, default: 0 },
+        refId: { type: String, required: false },
+        replicationId: { type: Number, required: false, default: 0 },
+    }, { timestamps: true });
+    return mongoose.model<ILivingSpaces>(collectionName, LivingSpacesSchema, collectionName);
+}
+
+export { getDynamicLivingSpaceModel };
+export type { ILivingSpaces };

models/People.ts

@@ -0,0 +1,41 @@
+import mongoose, { Schema, models, Document, Model } from "mongoose";
+import { Base } from "./base";
+
+interface IPerson extends Base, Document {
+    firstName: string;
+    surname: string;
+    middleName: string;
+    sexCode: string;
+    personRef: string;
+    personTag: string;
+    fatherName: string;
+    motherName: string;
+    countryCode: string;
+    nationalIdentityId: string;
+    birthPlace: string;
+    birthDate: Date;
+    taxNo: string;
+    birthname: string;
+}
+
+const PersonSchema = new Schema<IPerson>({
+    firstName: { type: String, required: true },
+    surname: { type: String, required: true },
+    middleName: { type: String, required: true },
+    sexCode: { type: String, required: true },
+    personRef: { type: String, required: true },
+    personTag: { type: String, required: true },
+    fatherName: { type: String, required: true },
+    motherName: { type: String, required: true },
+    countryCode: { type: String, required: true },
+    nationalIdentityId: { type: String, required: true },
+    birthPlace: { type: String, required: true },
+    birthDate: { type: Date, required: true },
+    taxNo: { type: String, required: true },
+    birthname: { type: String, required: true },
+});
+
+const Person: Model<IPerson> = models.Person || mongoose.model<IPerson>("Person", PersonSchema);
+
+export { Person };
+export type { IPerson }

models/User.ts

@@ -1,10 +0,0 @@
-import mongoose, { Schema, models } from 'mongoose';
-
-const UserSchema = new Schema({
-    name: { type: String, required: true },
-    email: { type: String, required: true, unique: true },
-});
-
-const User = models.User || mongoose.model('User', UserSchema);
-
-export default User;

models/UserTypes.ts

@@ -0,0 +1,20 @@
+import mongoose, { Schema, models } from "mongoose";
+
+interface IUserType {
+    type: string;
+    token: string;
+    typeToken: string;
+    description: string;
+}
+
+const UserTypesSchema = new Schema<IUserType>({
+    type: { type: String, required: true },
+    token: { type: String, required: true },
+    typeToken: { type: String, required: true },
+    description: { type: String, required: true },
+});
+
+const UserTypes = models.UserTypes || mongoose.model("UserTypes", UserTypesSchema);
+
+export { UserTypes };
+export type { IUserType };

models/Users.ts

@@ -0,0 +1,62 @@
+import mongoose, { Schema, models, Document } from "mongoose";
+import { BaseSchema, Base } from "./base";
+
+const expiresDate = () => new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+
+interface ICollectionToken {
+    tokens: { prefix: string; token: string }[];
+    default: string;
+}
+
+interface IUser extends Base, Document {
+    expiresAt?: Date;
+    resetToken?: string;
+    password: string;
+    history?: string[];
+    tag: string;
+    email: string;
+    phone: string;
+    collectionTokens: ICollectionToken;
+    person: mongoose.Types.ObjectId;
+    type?: mongoose.Types.ObjectId;
+}
+
+const CollectionTokenSchema = new Schema<ICollectionToken>(
+    {
+        tokens: { type: [{ prefix: { type: String, required: true }, token: { type: String, required: true } }], default: [], required: false },
+        default: { type: String, required: true, default: "" },
+    },
+    { _id: false }
+);
+
+
+const UsersSchema = new Schema<IUser>(
+    {
+        ...BaseSchema,
+        expiresAt: { type: Date, default: expiresDate, required: false },
+        resetToken: { type: String, required: false },
+        password: { type: String, required: true },
+        history: {
+            type: [String],
+            validate: [(val: string[]) => val.length <= 3, "History can have max 3 items"],
+            default: [],
+            required: false,
+        },
+        tag: { type: String, required: true },
+        email: { type: String, required: true, unique: true },
+        phone: { type: String, required: true, unique: true },
+        collectionTokens: {
+            type: CollectionTokenSchema,
+            default: () => ({ tokens: [], default: "" }),
+            required: true,
+        },
+        person: { type: Schema.Types.ObjectId, ref: "Person", required: true },
+        type: { type: Schema.Types.ObjectId, ref: "UserType", required: false },
+    },
+    { timestamps: true }
+);
+
+const Users = models.Users || mongoose.model("Users", UsersSchema);
+
+export { Users };
+export type { IUser, ICollectionToken };

models/base.ts

@@ -0,0 +1,47 @@
+import { randomUUID } from "crypto";
+
+interface Base {
+    uuid: string;
+
+    expiryStarts: Date;
+    expiryEnds: Date;
+
+    createdAt: Date;
+    updatedAt: Date;
+
+    isConfirmed: boolean;
+    deleted: boolean;
+    active: boolean;
+
+    crypUuId: string;
+    createdCredentialsToken: string;
+    updatedCredentialsToken: string;
+    confirmedCredentialsToken: string;
+    isNotificationSend: boolean;
+    isEmailSend: boolean;
+
+    refInt: number;
+    refId: string;
+    replicationId: number;
+}
+
+const BaseSchema = {
+    uuid: { type: String, required: false, unique: true, default: randomUUID },
+    expiryStarts: { type: Date, required: false, default: () => new Date(Date.now()) },
+    expiryEnds: { type: Date, required: false, default: () => new Date('2099-12-31') },
+    isConfirmed: { type: Boolean, required: false, default: false },
+    deleted: { type: Boolean, required: false, default: false },
+    active: { type: Boolean, required: false, default: true },
+    crypUuId: { type: String, required: false, default: randomUUID },
+    createdCredentialsToken: { type: String, required: false, default: randomUUID },
+    updatedCredentialsToken: { type: String, required: false, default: randomUUID },
+    confirmedCredentialsToken: { type: String, required: false, default: randomUUID },
+    isNotificationSend: { type: Boolean, required: false, default: false },
+    isEmailSend: { type: Boolean, required: false, default: false },
+    refInt: { type: Number, required: false, default: 0 },
+    refId: { type: String, required: false, default: randomUUID },
+    replicationId: { type: Number, required: false, default: 0 },
+};
+
+export { BaseSchema };
+export type { Base };