@loomcore/api 0.1.53 → 0.1.57

package/dist/services/generic-api-service/generic-api.service.d.ts

@@ -1,5 +1,6 @@
 import { ValueError } from '@sinclair/typebox/errors';
 import { IUserContext, IEntity, IQueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
 import { IGenericApiService } from './generic-api-service.interface.js';
 import { Operation } from '../../databases/operations/operation.js';
 import { DeleteResult } from '../../databases/models/delete-result.js';
@@ -17,20 +18,20 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     };
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
     validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
-    preprocessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId?: boolean): Promise<Partial<T>>;
-    postprocessEntity(userContext: IUserContext, entity: T): T;
+    preProcessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId?: boolean): Promise<Partial<T>>;
+    postProcessEntity(userContext: IUserContext, entity: T): T;
     get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
     protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
-    getById(userContext: IUserContext, id: string): Promise<T>;
+    getById(userContext: IUserContext, id: AppIdType): Promise<T>;
     getCount(userContext: IUserContext): Promise<number>;
     create(userContext: IUserContext, entity: Partial<T>): Promise<T | null>;
     createMany(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
     batchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
-    fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
-    partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
-    partialUpdateByIdWithoutPreAndPostProcessing(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
+    fullUpdateById(userContext: IUserContext, id: AppIdType, entity: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: AppIdType, entity: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutPreAndPostProcessing(userContext: IUserContext, id: AppIdType, entity: Partial<T>): Promise<T>;
     update(userContext: IUserContext, queryObject: IQueryOptions, entity: Partial<T>): Promise<T[]>;
-    deleteById(userContext: IUserContext, id: string): Promise<DeleteResult>;
+    deleteById(userContext: IUserContext, id: AppIdType): Promise<DeleteResult>;
     deleteMany(userContext: IUserContext, queryObject: IQueryOptions): Promise<DeleteResult>;
     find(userContext: IUserContext, queryObject: IQueryOptions): Promise<T[]>;
     findOne(userContext: IUserContext, queryObject: IQueryOptions): Promise<T | null>;

package/dist/services/generic-api-service/generic-api.service.js

@@ -19,7 +19,7 @@ export class GenericApiService {
     async getAll(userContext) {
         const { operations } = this.prepareQuery(userContext, {}, []);
         const entities = await this.database.getAll(operations, this.pluralResourceName);
-        return entities.map(entity => this.postprocessEntity(userContext, entity));
+        return entities.map(entity => this.postProcessEntity(userContext, entity));
     }
     prepareQuery(userContext, queryObject, operations) {
         return { queryObject, operations };
@@ -39,7 +39,7 @@ export class GenericApiService {
         }
         return allErrors.length > 0 ? allErrors : null;
     }
-    async preprocessEntity(userContext, entity, isCreate, allowId = true) {
+    async preProcessEntity(userContext, entity, isCreate, allowId = true) {
         let preparedEntity = _.clone(entity);
         stripSenderProvidedSystemProperties(userContext, preparedEntity, allowId);
         if (this.modelSpec.isAuditable) {
@@ -57,17 +57,17 @@ export class GenericApiService {
         if (this.modelSpec) {
             cleanedEntity = this.modelSpec.decode(preparedEntity);
         }
-        preparedEntity = this.database.preprocessEntity(cleanedEntity, this.modelSpec.fullSchema);
+        preparedEntity = this.database.preProcessEntity(cleanedEntity, this.modelSpec.fullSchema);
         return preparedEntity;
     }
-    postprocessEntity(userContext, entity) {
-        return this.database.postprocessEntity(entity, this.modelSpec.fullSchema);
+    postProcessEntity(userContext, entity) {
+        return this.database.postProcessEntity(entity, this.modelSpec.fullSchema);
     }
     async get(userContext, queryOptions = { ...DefaultQueryOptions }) {
         const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
         const { operations } = this.prepareQuery(userContext, {}, []);
         const pagedResult = await this.database.get(operations, preparedOptions, this.modelSpec, this.pluralResourceName);
-        const transformedEntities = (pagedResult.entities || []).map(entity => this.postprocessEntity(userContext, entity));
+        const transformedEntities = (pagedResult.entities || []).map(entity => this.postProcessEntity(userContext, entity));
         return {
             ...pagedResult,
             entities: transformedEntities
@@ -82,7 +82,7 @@ export class GenericApiService {
         if (!entity) {
             throw new IdNotFoundError();
         }
-        return this.postprocessEntity(userContext, entity);
+        return this.postProcessEntity(userContext, entity);
     }
     async getCount(userContext) {
         this.prepareQuery(userContext, {}, []);
@@ -90,20 +90,20 @@ export class GenericApiService {
     }
     async create(userContext, entity) {
         let createdEntity = null;
-        const preparedEntity = await this.preprocessEntity(userContext, entity, true, true);
+        const preparedEntity = await this.preProcessEntity(userContext, entity, true, true);
         const insertResult = await this.database.create(preparedEntity, this.pluralResourceName);
         if (insertResult.insertedId) {
-            createdEntity = this.postprocessEntity(userContext, insertResult.entity);
+            createdEntity = this.postProcessEntity(userContext, insertResult.entity);
         }
         return createdEntity;
     }
     async createMany(userContext, entities) {
         let createdEntities = [];
         if (entities.length) {
-            const preparedEntities = await Promise.all(entities.map(entity => this.preprocessEntity(userContext, entity, true, true)));
+            const preparedEntities = await Promise.all(entities.map(entity => this.preProcessEntity(userContext, entity, true, true)));
             const insertResult = await this.database.createMany(preparedEntities, this.pluralResourceName);
             if (insertResult.insertedIds) {
-                createdEntities = insertResult.entities.map(entity => this.postprocessEntity(userContext, entity));
+                createdEntities = insertResult.entities.map(entity => this.postProcessEntity(userContext, entity));
             }
         }
         return createdEntities;
@@ -112,10 +112,10 @@ export class GenericApiService {
         if (!entities || entities.length === 0) {
             return [];
         }
-        const preparedEntities = await Promise.all(entities.map(entity => this.preprocessEntity(userContext, entity, false, true)));
+        const preparedEntities = await Promise.all(entities.map(entity => this.preProcessEntity(userContext, entity, false, true)));
         const { queryObject, operations } = this.prepareQuery(userContext, {}, []);
         const rawUpdatedEntities = await this.database.batchUpdate(preparedEntities, operations, queryObject, this.pluralResourceName);
-        const updatedEntities = rawUpdatedEntities.map(entity => this.postprocessEntity(userContext, entity));
+        const updatedEntities = rawUpdatedEntities.map(entity => this.postProcessEntity(userContext, entity));
         return updatedEntities;
     }
     async fullUpdateById(userContext, id, entity) {
@@ -128,29 +128,29 @@ export class GenericApiService {
             _created: existingEntity._created,
             _createdBy: existingEntity._createdBy,
         };
-        const preparedEntity = await this.preprocessEntity(userContext, entity, false, true);
+        const preparedEntity = await this.preProcessEntity(userContext, entity, false, true);
         Object.assign(preparedEntity, auditProperties);
         const rawUpdatedEntity = await this.database.fullUpdateById(operations, id, preparedEntity, this.pluralResourceName);
-        const updatedEntity = this.postprocessEntity(userContext, rawUpdatedEntity);
+        const updatedEntity = this.postProcessEntity(userContext, rawUpdatedEntity);
         return updatedEntity;
     }
     async partialUpdateById(userContext, id, entity) {
         const { operations } = this.prepareQuery(userContext, {}, []);
-        const preparedEntity = await this.preprocessEntity(userContext, entity, false, true);
+        const preparedEntity = await this.preProcessEntity(userContext, entity, false, true);
         const rawUpdatedEntity = await this.database.partialUpdateById(operations, id, preparedEntity, this.pluralResourceName);
-        const updatedEntity = this.postprocessEntity(userContext, rawUpdatedEntity);
+        const updatedEntity = this.postProcessEntity(userContext, rawUpdatedEntity);
         return updatedEntity;
     }
     async partialUpdateByIdWithoutPreAndPostProcessing(userContext, id, entity) {
-        const preparedEntity = this.database.preprocessEntity(entity, this.modelSpec.fullSchema);
+        const preparedEntity = this.database.preProcessEntity(entity, this.modelSpec.fullSchema);
         const rawUpdatedEntity = await this.database.partialUpdateById([], id, preparedEntity, this.pluralResourceName);
-        return this.database.postprocessEntity(rawUpdatedEntity, this.modelSpec.fullSchema);
+        return this.database.postProcessEntity(rawUpdatedEntity, this.modelSpec.fullSchema);
     }
     async update(userContext, queryObject, entity) {
         const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
-        const preparedEntity = await this.preprocessEntity(userContext, entity, false, true);
+        const preparedEntity = await this.preProcessEntity(userContext, entity, false, true);
         const rawUpdatedEntities = await this.database.update(preparedQuery, preparedEntity, operations, this.pluralResourceName);
-        const updatedEntities = rawUpdatedEntities.map(entity => this.postprocessEntity(userContext, entity));
+        const updatedEntities = rawUpdatedEntities.map(entity => this.postProcessEntity(userContext, entity));
         return updatedEntities;
     }
     async deleteById(userContext, id) {
@@ -168,11 +168,11 @@ export class GenericApiService {
     async find(userContext, queryObject) {
         const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
         const rawEntities = await this.database.find(preparedQuery, this.pluralResourceName);
-        return rawEntities.map(entity => this.postprocessEntity(userContext, entity));
+        return rawEntities.map(entity => this.postProcessEntity(userContext, entity));
     }
     async findOne(userContext, queryObject) {
         const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
         const rawEntity = await this.database.findOne(preparedQuery, this.pluralResourceName);
-        return rawEntity ? this.postprocessEntity(userContext, rawEntity) : null;
+        return rawEntity ? this.postProcessEntity(userContext, rawEntity) : null;
     }
 }

package/dist/services/multi-tenant-api.service.d.ts

@@ -9,5 +9,5 @@ export declare class MultiTenantApiService<T extends IEntity> extends GenericApi
         queryObject: IQueryOptions;
         operations: Operation[];
     };
-    preprocessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId?: boolean): Promise<Partial<T>>;
+    preProcessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId?: boolean): Promise<Partial<T>>;
 }

package/dist/services/multi-tenant-api.service.js

@@ -20,14 +20,14 @@ export class MultiTenantApiService extends GenericApiService {
         const queryObject = this.tenantDecorator.applyTenantToQuery(userContext, queryOptions, this.pluralResourceName);
         return { queryObject, operations };
     }
-    async preprocessEntity(userContext, entity, isCreate, allowId = false) {
+    async preProcessEntity(userContext, entity, isCreate, allowId = false) {
         if (!config?.app?.isMultiTenant) {
-            return super.preprocessEntity(userContext, entity, isCreate, allowId);
+            return super.preProcessEntity(userContext, entity, isCreate, allowId);
         }
         if (!userContext || !userContext.organization?._id) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareEntity');
         }
-        const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate, allowId);
+        const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate, allowId);
         if (isCreate && userContext.user._id !== 'system') {
             preparedEntity._orgId = userContext.organization?._id;
         }

package/dist/services/organization.service.d.ts

@@ -1,10 +1,11 @@
 import { IOrganization, IUserContext } from '@loomcore/common/models';
 import { IDatabase } from '../databases/models/database.interface.js';
 import { GenericApiService } from './generic-api-service/generic-api.service.js';
+import { AppIdType } from '@loomcore/common/types';
 export declare class OrganizationService extends GenericApiService<IOrganization> {
     constructor(database: IDatabase);
-    preprocessEntity(userContext: IUserContext, entity: Partial<IOrganization>, isCreate: boolean, allowId?: boolean): Promise<Partial<IOrganization>>;
-    getAuthTokenByRepoCode(userContext: IUserContext, orgId: string): Promise<string | null>;
-    validateRepoAuthToken(userContext: IUserContext, orgCode: string, authToken: string): Promise<string | null>;
+    preProcessEntity(userContext: IUserContext, entity: Partial<IOrganization>, isCreate: boolean, allowId?: boolean): Promise<Partial<IOrganization>>;
+    getAuthTokenByRepoCode(userContext: IUserContext, orgId: AppIdType): Promise<string | null>;
+    validateRepoAuthToken(userContext: IUserContext, orgCode: string, authToken: string): Promise<AppIdType | null>;
     getMetaOrg(userContext: IUserContext): Promise<IOrganization | null>;
 }

package/dist/services/organization.service.js

@@ -5,7 +5,7 @@ export class OrganizationService extends GenericApiService {
     constructor(database) {
         super(database, 'organizations', 'organization', OrganizationSpec);
     }
-    async preprocessEntity(userContext, entity, isCreate, allowId = true) {
+    async preProcessEntity(userContext, entity, isCreate, allowId = true) {
         if (isCreate) {
             const metaOrg = await this.getMetaOrg(userContext);
             if (metaOrg && entity.isMetaOrg) {
@@ -15,7 +15,7 @@ export class OrganizationService extends GenericApiService {
                 throw new BadRequestError('User is not authorized to create an organization');
             }
         }
-        const result = await super.preprocessEntity(userContext, entity, isCreate, allowId);
+        const result = await super.preProcessEntity(userContext, entity, isCreate, allowId);
         return result;
     }
     async getAuthTokenByRepoCode(userContext, orgId) {
@@ -27,7 +27,7 @@ export class OrganizationService extends GenericApiService {
         if (!org) {
             return null;
         }
-        const orgId = org.authToken === authToken ? org._id.toString() : null;
+        const orgId = org.authToken === authToken ? org._id : null;
         return orgId;
     }
     async getMetaOrg(userContext) {

package/dist/services/user.service.d.ts

@@ -1,8 +1,9 @@
 import { IUser, IUserContext } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
 import { MultiTenantApiService } from './index.js';
 import { IDatabase } from '../databases/models/index.js';
 export declare class UserService extends MultiTenantApiService<IUser> {
     constructor(database: IDatabase);
-    fullUpdateById(userContext: IUserContext, id: string, entity: IUser): Promise<IUser>;
-    preprocessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId?: boolean): Promise<Partial<IUser>>;
+    fullUpdateById(userContext: IUserContext, id: AppIdType, entity: IUser): Promise<IUser>;
+    preProcessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId?: boolean): Promise<Partial<IUser>>;
 }

package/dist/services/user.service.js

@@ -9,8 +9,8 @@ export class UserService extends MultiTenantApiService {
     async fullUpdateById(userContext, id, entity) {
         throw new ServerError('Cannot full update a user. Either use PATCH or /auth/change-password to update password.');
     }
-    async preprocessEntity(userContext, entity, isCreate, allowId = false) {
-        const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate);
+    async preProcessEntity(userContext, entity, isCreate, allowId = false) {
+        const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate);
         if (preparedEntity.email) {
             preparedEntity.email = preparedEntity.email.toLowerCase();
         }

package/dist/services/utils/audit-for-create.util.js

@@ -1,7 +1,8 @@
+import { getSystemUserId } from "@loomcore/common/validation";
 import moment from "moment";
 export function auditForCreate(userContext, doc) {
     const now = moment().utc().toDate();
-    const userId = userContext.user?._id?.toString() ?? 'system';
+    const userId = userContext.user?._id ?? getSystemUserId();
     doc._created = now;
     doc._createdBy = userId;
     doc._updated = now;

package/dist/services/utils/audit-for-update.util.js

@@ -1,6 +1,7 @@
+import { getSystemUserId } from "@loomcore/common/validation";
 import moment from "moment";
 export function auditForUpdate(userContext, doc) {
-    const userId = userContext.user?._id?.toString() ?? 'system';
+    const userId = userContext.user?._id ?? getSystemUserId();
     doc._updated = moment().utc().toDate();
     doc._updatedBy = userId;
 }

package/dist/services/utils/strip-sender-provided-system-properties.util.js

@@ -1,5 +1,6 @@
+import { getSystemUserId } from "@loomcore/common/validation";
 export function stripSenderProvidedSystemProperties(userContext, entity, allowId = false) {
-    const isSystemUser = userContext.user?._id === 'system';
+    const isSystemUser = userContext.user?._id === getSystemUserId();
     if (isSystemUser) {
         return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.53",
+  "version": "0.1.57",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -53,7 +53,7 @@
     "qs": "^6.14.0"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.32",
+    "@loomcore/common": "^0.0.43",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

package/dist/__tests__/postgres-test-migrations/100-create-test-entities-table.migration.d.ts

@@ -1,21 +0,0 @@
-import { Client } from "pg";
-import { IMigration } from "../../databases/postgres/migrations/migration.interface.js";
-export declare class CreateTestEntitiesTableMigration implements IMigration {
-    private readonly client;
-    constructor(client: Client);
-    index: number;
-    execute(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-    revert(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-}

package/dist/__tests__/postgres-test-migrations/100-create-test-entities-table.migration.js

@@ -1,61 +0,0 @@
-import { randomUUID } from "crypto";
-export class CreateTestEntitiesTableMigration {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    index = 100;
-    async execute() {
-        const _id = randomUUID().toString();
-        try {
-            await this.client.query(`
-                CREATE TABLE "testEntities" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "name" VARCHAR(255) NOT NULL,
-                    "description" TEXT,
-                    "isActive" BOOLEAN,
-                    "tags" TEXT[],
-                    "count" INTEGER,
-                    "_created" TIMESTAMP NOT NULL,
-                    "_createdBy" VARCHAR(255) NOT NULL,
-                    "_updated" TIMESTAMP NOT NULL,
-                    "_updatedBy" VARCHAR(255) NOT NULL,
-                    "_deleted" TIMESTAMP,
-                    "_deletedBy" VARCHAR(255)
-                )
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error creating test entities table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
-                `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-    async revert() {
-        try {
-            await this.client.query(`
-                DROP TABLE test_entities;
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error dropping test entities table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-}

package/dist/__tests__/postgres-test-migrations/101-create-categories-table.migration.d.ts

@@ -1,21 +0,0 @@
-import { IMigration } from "../../databases/postgres/migrations/index.js";
-import { Client } from "pg";
-export declare class CreateCategoriesTableMigration implements IMigration {
-    private readonly client;
-    constructor(client: Client);
-    index: number;
-    execute(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-    revert(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-}

package/dist/__tests__/postgres-test-migrations/101-create-categories-table.migration.js

@@ -1,51 +0,0 @@
-import { randomUUID } from "crypto";
-export class CreateCategoriesTableMigration {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    index = 101;
-    async execute() {
-        const _id = randomUUID().toString();
-        try {
-            await this.client.query(`
-                CREATE TABLE "categories" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "name" VARCHAR(255) NOT NULL
-                )
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error creating categories table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
-                `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-    async revert() {
-        try {
-            await this.client.query(`
-                DROP TABLE "categories";
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error dropping categories table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-}

package/dist/__tests__/postgres-test-migrations/102-create-products-table.migration.d.ts

@@ -1,21 +0,0 @@
-import { Client } from "pg";
-import { IMigration } from "../../databases/postgres/migrations/index.js";
-export declare class CreateProductsTableMigration implements IMigration {
-    private readonly client;
-    constructor(client: Client);
-    index: number;
-    execute(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-    revert(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-}

package/dist/__tests__/postgres-test-migrations/102-create-products-table.migration.js

@@ -1,60 +0,0 @@
-import { randomUUID } from "crypto";
-export class CreateProductsTableMigration {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    index = 102;
-    async execute() {
-        const _id = randomUUID().toString();
-        try {
-            await this.client.query(`
-                CREATE TABLE "products" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "name" VARCHAR(255) NOT NULL,
-                    "description" TEXT,
-                    "internalNumber" VARCHAR(255),
-                    "categoryId" VARCHAR(255) NOT NULL REFERENCES "categories"("_id"),
-                    "_created" TIMESTAMP NOT NULL,
-                    "_createdBy" VARCHAR(255) NOT NULL,
-                    "_updated" TIMESTAMP NOT NULL,
-                    "_updatedBy" VARCHAR(255) NOT NULL,
-                    "_deleted" TIMESTAMP,
-                    "_deletedBy" VARCHAR(255)
-                )
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error creating products table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
-                `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-    async revert() {
-        try {
-            await this.client.query(`
-                DROP TABLE "products";
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error dropping products table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-}

package/dist/__tests__/postgres-test-migrations/103-create-test-items-table.migration.d.ts

@@ -1,21 +0,0 @@
-import { Client } from "pg";
-import { IMigration } from "../../databases/postgres/migrations/index.js";
-export declare class CreateTestItemsTableMigration implements IMigration {
-    private readonly client;
-    constructor(client: Client);
-    index: number;
-    execute(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-    revert(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-}

package/dist/__tests__/postgres-test-migrations/103-create-test-items-table.migration.js

@@ -1,59 +0,0 @@
-import { randomUUID } from "crypto";
-export class CreateTestItemsTableMigration {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    index = 103;
-    async execute() {
-        const _id = randomUUID().toString();
-        try {
-            await this.client.query(`
-                CREATE TABLE "testItems" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "name" VARCHAR(255) NOT NULL,
-                    "value" INTEGER,
-                    "eventDate" TIMESTAMP,
-                    "_created" TIMESTAMP NOT NULL,
-                    "_createdBy" VARCHAR(255) NOT NULL,
-                    "_updated" TIMESTAMP NOT NULL,
-                    "_updatedBy" VARCHAR(255) NOT NULL,
-                    "_deleted" TIMESTAMP,
-                    "_deletedBy" VARCHAR(255)
-                )
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error creating test items table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
-                `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-    async revert() {
-        try {
-            await this.client.query(`
-                DROP TABLE "testItems";
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error dropping test items table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-}

package/dist/__tests__/postgres-test-migrations/test-migrations.d.ts

@@ -1,3 +0,0 @@
-import { Client } from "pg";
-import { IMigration } from "../../databases/index.js";
-export declare const testMigrations: (client: Client) => IMigration[];