@loomcore/api 0.1.53 → 0.1.57

package/dist/databases/mongo-db/commands/mongo-delete-by-id.command.d.ts

@@ -1,3 +1,4 @@
 import { Db } from "mongodb";
 import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
-export declare function deleteById(db: Db, id: string, pluralResourceName: string): Promise<GenericDeleteResult>;
+import type { AppIdType } from "@loomcore/common/types";
+export declare function deleteById(db: Db, id: AppIdType, pluralResourceName: string): Promise<GenericDeleteResult>;

package/dist/databases/mongo-db/commands/mongo-full-updateby-id.command.d.ts

@@ -1,3 +1,4 @@
 import { Db } from "mongodb";
 import { Operation } from "../../operations/operation.js";
-export declare function fullUpdateById<T>(db: Db, operations: Operation[], id: string, entity: any, pluralResourceName: string): Promise<T>;
+import type { AppIdType } from "@loomcore/common/types";
+export declare function fullUpdateById<T>(db: Db, operations: Operation[], id: AppIdType, entity: any, pluralResourceName: string): Promise<T>;

package/dist/databases/mongo-db/commands/mongo-partial-update-by-id.command.d.ts

@@ -1,3 +1,4 @@
 import { Db } from "mongodb";
 import { Operation } from "../../operations/operation.js";
-export declare function partialUpdateById<T>(db: Db, operations: Operation[], id: string, entity: Partial<any>, pluralResourceName: string): Promise<T>;
+import type { AppIdType } from "@loomcore/common/types";
+export declare function partialUpdateById<T>(db: Db, operations: Operation[], id: AppIdType, entity: Partial<any>, pluralResourceName: string): Promise<T>;

package/dist/databases/mongo-db/migrations/{mongo-foundational.d.ts → mongo-initial-schema.d.ts}

@@ -9,4 +9,4 @@ export interface SyntheticMigration {
         context: Db;
     }) => Promise<void>;
 }
-export declare const getMongoFoundational: (config: IBaseApiConfig) => SyntheticMigration[];
+export declare const getMongoInitialSchema: (config: IBaseApiConfig) => SyntheticMigration[];

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -0,0 +1,264 @@
+import { randomUUID } from 'crypto';
+import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext } from '@loomcore/common/models';
+import { MongoDBDatabase } from '../mongo-db.database.js';
+import { AuthService, OrganizationService } from '../../../services/index.js';
+export const getMongoInitialSchema = (config) => {
+    const migrations = [];
+    const isMultiTenant = config.app.isMultiTenant === true;
+    if (isMultiTenant) {
+        migrations.push({
+            name: '00000000000001_schema-organizations',
+            up: async ({ context: db }) => {
+                await db.createCollection('organizations');
+                await db.collection('organizations').createIndex({ name: 1 }, { unique: true });
+                await db.collection('organizations').createIndex({ code: 1 }, { unique: true });
+                await db.collection('organizations').createIndex({ isMetaOrg: 1 });
+            },
+            down: async ({ context: db }) => {
+                await db.collection('organizations').drop();
+            }
+        });
+    }
+    migrations.push({
+        name: '00000000000002_schema-users',
+        up: async ({ context: db }) => {
+            await db.createCollection('users');
+            if (isMultiTenant) {
+                await db.collection('users').createIndex({ _orgId: 1, email: 1 }, { unique: true });
+                await db.collection('users').createIndex({ _orgId: 1 });
+            }
+            else {
+                await db.collection('users').createIndex({ email: 1 }, { unique: true });
+            }
+        },
+        down: async ({ context: db }) => {
+            await db.collection('users').drop();
+        }
+    });
+    migrations.push({
+        name: '00000000000003_schema-refresh-tokens',
+        up: async ({ context: db }) => {
+            await db.createCollection('refreshTokens');
+            await db.collection('refreshTokens').createIndex({ token: 1 }, { unique: true });
+            await db.collection('refreshTokens').createIndex({ userId: 1 });
+            await db.collection('refreshTokens').createIndex({ deviceId: 1 });
+            if (isMultiTenant) {
+                await db.collection('refreshTokens').createIndex({ _orgId: 1 });
+            }
+        },
+        down: async ({ context: db }) => {
+            await db.collection('refreshTokens').drop();
+        }
+    });
+    migrations.push({
+        name: '00000000000004_schema-roles',
+        up: async ({ context: db }) => {
+            await db.createCollection('roles');
+            if (isMultiTenant) {
+                await db.collection('roles').createIndex({ _orgId: 1, name: 1 }, { unique: true });
+                await db.collection('roles').createIndex({ _orgId: 1 });
+            }
+            else {
+                await db.collection('roles').createIndex({ name: 1 }, { unique: true });
+            }
+        },
+        down: async ({ context: db }) => {
+            await db.collection('roles').drop();
+        }
+    });
+    migrations.push({
+        name: '00000000000005_schema-user-roles',
+        up: async ({ context: db }) => {
+            await db.createCollection('user_roles');
+            if (isMultiTenant) {
+                await db.collection('user_roles').createIndex({ _orgId: 1, userId: 1, roleId: 1 }, { unique: true });
+                await db.collection('user_roles').createIndex({ _orgId: 1 });
+            }
+            else {
+                await db.collection('user_roles').createIndex({ userId: 1, roleId: 1 }, { unique: true });
+            }
+            await db.collection('user_roles').createIndex({ userId: 1 });
+            await db.collection('user_roles').createIndex({ roleId: 1 });
+        },
+        down: async ({ context: db }) => {
+            await db.collection('user_roles').drop();
+        }
+    });
+    migrations.push({
+        name: '00000000000006_schema-features',
+        up: async ({ context: db }) => {
+            await db.createCollection('features');
+            if (isMultiTenant) {
+                await db.collection('features').createIndex({ _orgId: 1, name: 1 }, { unique: true });
+                await db.collection('features').createIndex({ _orgId: 1 });
+            }
+            else {
+                await db.collection('features').createIndex({ name: 1 }, { unique: true });
+            }
+        },
+        down: async ({ context: db }) => {
+            await db.collection('features').drop();
+        }
+    });
+    migrations.push({
+        name: '00000000000007_schema-authorizations',
+        up: async ({ context: db }) => {
+            await db.createCollection('authorizations');
+            if (isMultiTenant) {
+                await db.collection('authorizations').createIndex({ _orgId: 1, roleId: 1, featureId: 1 }, { unique: true });
+                await db.collection('authorizations').createIndex({ _orgId: 1 });
+            }
+            else {
+                await db.collection('authorizations').createIndex({ roleId: 1, featureId: 1 }, { unique: true });
+            }
+            await db.collection('authorizations').createIndex({ roleId: 1 });
+            await db.collection('authorizations').createIndex({ featureId: 1 });
+        },
+        down: async ({ context: db }) => {
+            await db.collection('authorizations').drop();
+        }
+    });
+    if (isMultiTenant && config.app.metaOrgName && config.app.metaOrgCode) {
+        migrations.push({
+            name: '00000000000008_data-meta-org',
+            up: async ({ context: db }) => {
+                const _id = randomUUID().toString();
+                const metaOrg = {
+                    _id,
+                    name: config.app.metaOrgName,
+                    code: config.app.metaOrgCode,
+                    description: undefined,
+                    status: 1,
+                    isMetaOrg: true,
+                    authToken: undefined,
+                    _created: new Date(),
+                    _createdBy: 'system',
+                    _updated: new Date(),
+                    _updatedBy: 'system',
+                    _deleted: undefined,
+                    _deletedBy: undefined
+                };
+                await db.collection('organizations').insertOne(metaOrg);
+                initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', metaOrg);
+            },
+            down: async ({ context: db }) => {
+                await db.collection('organizations').deleteMany({ isMetaOrg: true });
+            }
+        });
+    }
+    if (config.adminUser?.email && config.adminUser?.password) {
+        migrations.push({
+            name: '00000000000009_data-admin-user',
+            up: async ({ context: db }) => {
+                if (!config.adminUser?.email || !config.adminUser?.password) {
+                    throw new Error('Admin user email and password must be provided in config');
+                }
+                const database = new MongoDBDatabase(db);
+                const authService = new AuthService(database);
+                const systemUserContext = getSystemUserContext();
+                const _id = randomUUID().toString();
+                await authService.createUser(systemUserContext, {
+                    _id: _id,
+                    _orgId: systemUserContext.organization?._id,
+                    email: config.adminUser.email,
+                    password: config.adminUser.password,
+                    firstName: 'Admin',
+                    lastName: 'User',
+                    displayName: 'Admin User',
+                });
+            },
+            down: async ({ context: db }) => {
+                if (!config.adminUser?.email)
+                    return;
+                await db.collection('users').deleteOne({ email: config.adminUser.email });
+            }
+        });
+    }
+    if (config.adminUser?.email && isMultiTenant) {
+        migrations.push({
+            name: '00000000000010_data-admin-authorizations',
+            up: async ({ context: db }) => {
+                if (!config.adminUser?.email) {
+                    throw new Error('Admin user email not found in config');
+                }
+                const database = new MongoDBDatabase(db);
+                const organizationService = new OrganizationService(database);
+                const authService = new AuthService(database);
+                const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
+                if (!metaOrg) {
+                    throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
+                }
+                const adminUser = await authService.getUserByEmail(config.adminUser.email);
+                if (!adminUser) {
+                    throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
+                }
+                const roleId = randomUUID().toString();
+                await db.collection('roles').insertOne({
+                    _id: roleId,
+                    _orgId: metaOrg._id,
+                    name: 'admin'
+                });
+                const userRoleId = randomUUID().toString();
+                await db.collection('user_roles').insertOne({
+                    _id: userRoleId,
+                    _orgId: metaOrg._id,
+                    userId: adminUser._id,
+                    roleId: roleId,
+                    _created: new Date(),
+                    _createdBy: 'system',
+                    _updated: new Date(),
+                    _updatedBy: 'system',
+                    _deleted: undefined,
+                    _deletedBy: undefined
+                });
+                const featureId = randomUUID().toString();
+                await db.collection('features').insertOne({
+                    _id: featureId,
+                    _orgId: metaOrg._id,
+                    name: 'admin'
+                });
+                const authorizationId = randomUUID().toString();
+                await db.collection('authorizations').insertOne({
+                    _id: authorizationId,
+                    _orgId: metaOrg._id,
+                    roleId: roleId,
+                    featureId: featureId,
+                    startDate: undefined,
+                    endDate: undefined,
+                    config: undefined,
+                    _created: new Date(),
+                    _createdBy: 'system',
+                    _updated: new Date(),
+                    _updatedBy: 'system',
+                    _deleted: undefined,
+                    _deletedBy: undefined
+                });
+            },
+            down: async ({ context: db }) => {
+                const database = new MongoDBDatabase(db);
+                const organizationService = new OrganizationService(database);
+                const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
+                if (!metaOrg)
+                    return;
+                const adminRole = await db.collection('roles').findOne({ _orgId: metaOrg._id, name: 'admin' });
+                const adminFeature = await db.collection('features').findOne({ _orgId: metaOrg._id, name: 'admin' });
+                if (adminRole && adminFeature) {
+                    await db.collection('authorizations').deleteMany({
+                        _orgId: metaOrg._id,
+                        roleId: adminRole._id,
+                        featureId: adminFeature._id
+                    });
+                }
+                await db.collection('features').deleteMany({ _orgId: metaOrg._id, name: 'admin' });
+                if (adminRole) {
+                    await db.collection('user_roles').deleteMany({
+                        _orgId: metaOrg._id,
+                        roleId: adminRole._id
+                    });
+                }
+                await db.collection('roles').deleteMany({ _orgId: metaOrg._id, name: 'admin' });
+            }
+        });
+    }
+    return migrations;
+};

package/dist/databases/mongo-db/mongo-db.database.d.ts

@@ -1,5 +1,6 @@
 import { Db } from "mongodb";
 import { IModelSpec, IQueryOptions, IPagedResult, IEntity } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
 import { Operation } from "../operations/operation.js";
 import { DeleteResult as GenericDeleteResult } from "../models/delete-result.js";
 import { TSchema } from "@sinclair/typebox";
@@ -7,25 +8,25 @@ import { IDatabase } from "../models/database.interface.js";
 export declare class MongoDBDatabase implements IDatabase {
     private db;
     constructor(db: Db);
-    preprocessEntity<T extends IEntity>(entity: Partial<T>, schema: TSchema): Partial<T>;
-    postprocessEntity<T extends IEntity>(single: T, schema: TSchema): T;
+    preProcessEntity<T extends IEntity>(entity: Partial<T>, schema: TSchema): Partial<T>;
+    postProcessEntity<T extends IEntity>(single: T, schema: TSchema): T;
     getAll<T extends IEntity>(operations: Operation[], pluralResourceName: string): Promise<T[]>;
     get<T extends IEntity>(operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;
-    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: AppIdType, pluralResourceName: string): Promise<T | null>;
     getCount(pluralResourceName: string): Promise<number>;
     create<T extends IEntity>(entity: Partial<T>, pluralResourceName: string): Promise<{
-        insertedId: string;
+        insertedId: AppIdType;
         entity: T;
     }>;
     createMany<T extends IEntity>(entities: Partial<T>[], pluralResourceName: string): Promise<{
-        insertedIds: string[];
+        insertedIds: AppIdType[];
         entities: T[];
     }>;
     batchUpdate<T extends IEntity>(entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
-    fullUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
-    partialUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    fullUpdateById<T extends IEntity>(operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    partialUpdateById<T extends IEntity>(operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;
     update<T extends IEntity>(queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;
-    deleteById(id: string, pluralResourceName: string): Promise<GenericDeleteResult>;
+    deleteById(id: AppIdType, pluralResourceName: string): Promise<GenericDeleteResult>;
     deleteMany(queryObject: IQueryOptions, pluralResourceName: string): Promise<GenericDeleteResult>;
     find<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
     findOne<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;

package/dist/databases/mongo-db/mongo-db.database.js

@@ -8,13 +8,13 @@ export class MongoDBDatabase {
     constructor(db) {
         this.db = db;
     }
-    preprocessEntity(entity, schema) {
+    preProcessEntity(entity, schema) {
         if (entity._id && !entityUtils.isValidObjectId(entity._id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
         return convertStringsToObjectIds(entity, schema);
     }
-    postprocessEntity(single, schema) {
+    postProcessEntity(single, schema) {
         if (!single)
             return single;
         return convertObjectIdsToStrings(single);

package/dist/databases/mongo-db/queries/mongo-get-by-id.query.d.ts

@@ -1,4 +1,5 @@
 import { Db } from "mongodb";
 import { Operation } from "../../operations/operation.js";
 import { IQueryOptions } from "@loomcore/common/models";
-export declare function getById<T>(db: Db, operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+import type { AppIdType } from "@loomcore/common/types";
+export declare function getById<T>(db: Db, operations: Operation[], queryObject: IQueryOptions, id: AppIdType, pluralResourceName: string): Promise<T | null>;

package/dist/databases/postgres/commands/postgres-batch-update.command.js

@@ -9,7 +9,7 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
     }
     const entityIds = [];
     for (const entity of entities) {
-        if (!entity._id || typeof entity._id !== 'string') {
+        if (!entity._id || (typeof entity._id !== 'string' && typeof entity._id !== 'number')) {
             throw new BadRequestError('Each entity in a batch update must have a valid _id.');
         }
         entityIds.push(entity._id);

package/dist/databases/postgres/commands/postgres-create-many.command.d.ts

@@ -1,6 +1,7 @@
 import { Client } from 'pg';
 import { IEntity } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
 export declare function createMany<T extends IEntity>(client: Client, pluralResourceName: string, entities: Partial<T>[]): Promise<{
-    insertedIds: string[];
+    insertedIds: AppIdType[];
     entities: T[];
 }>;

package/dist/databases/postgres/commands/postgres-create-many.command.js

@@ -1,5 +1,4 @@
 import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
-import { randomUUID } from 'crypto';
 export async function createMany(client, pluralResourceName, entities) {
     if (entities.length === 0) {
         return {
@@ -8,50 +7,46 @@ export async function createMany(client, pluralResourceName, entities) {
         };
     }
     try {
-        const entitiesWithIds = entities.map(entity => {
-            entity._id = entity._id ?? randomUUID().toString();
-            return entity;
+        entities.forEach(entity => {
+            delete entity._id;
         });
-        const tableColumns = await client.query(`
-                SELECT column_name, column_default
-                FROM information_schema.columns
-                WHERE table_schema = current_schema()
-                  AND table_name = $1
-                ORDER BY ordinal_position
-            `, [pluralResourceName]);
-        if (tableColumns.rows.length === 0) {
-            throw new BadRequestError(`Unable to resolve columns for ${pluralResourceName}`);
+        const allColumns = new Set();
+        entities.forEach(entity => {
+            Object.keys(entity).forEach(key => {
+                if (key !== '_id') {
+                    allColumns.add(key);
+                }
+            });
+        });
+        const columns = Array.from(allColumns);
+        if (columns.length === 0) {
+            throw new BadRequestError(`No columns provided for ${pluralResourceName}`);
         }
         const allValues = [];
         const valueClauses = [];
-        entitiesWithIds.forEach((entity, entityIndex) => {
-            const objectEntries = Object.entries(entity);
-            const values = tableColumns.rows.map(column => {
-                if (objectEntries.find(entry => entry[0] === column.column_name)) {
-                    return objectEntries.find(entry => entry[0] === column.column_name)?.[1];
-                }
-                return column.column_default;
-            });
+        entities.forEach((entity, entityIndex) => {
+            const values = columns.map(column => entity[column]);
             const placeholders = values.map((_, valueIndex) => {
-                const paramIndex = entityIndex * values.length + valueIndex + 1;
+                const paramIndex = entityIndex * columns.length + valueIndex + 1;
                 return `$${paramIndex}`;
             }).join(', ');
             valueClauses.push(`(${placeholders})`);
             allValues.push(...values);
         });
         const query = `
-            INSERT INTO "${pluralResourceName}" (${tableColumns.rows.map(column => `"${column.column_name}"`).join(', ')})
+            INSERT INTO "${pluralResourceName}" (${columns.map(col => `"${col}"`).join(', ')})
             VALUES ${valueClauses.join(', ')}
-            RETURNING _id
+            RETURNING *
         `;
         const result = await client.query(query, allValues);
-        if (result.rows.length !== entitiesWithIds.length) {
-            throw new BadRequestError(`Error creating ${pluralResourceName}: Expected ${entitiesWithIds.length} rows, got ${result.rows.length}`);
+        if (result.rows.length !== entities.length) {
+            throw new BadRequestError(`Error creating ${pluralResourceName}: Expected ${entities.length} rows, got ${result.rows.length}`);
         }
-        const insertedIds = result.rows.map(row => row._id);
+        const insertedRows = result.rows;
+        const insertedIds = insertedRows.map(row => row._id);
         return {
             insertedIds,
-            entities: entitiesWithIds
+            entities: insertedRows
         };
     }
     catch (err) {

package/dist/databases/postgres/commands/postgres-create.command.d.ts

@@ -1,6 +1,7 @@
 import { Client } from 'pg';
 import { IEntity } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
 export declare function create<T extends IEntity>(client: Client, pluralResourceName: string, entity: Partial<T>): Promise<{
-    insertedId: string;
+    insertedId: AppIdType;
     entity: T;
 }>;

package/dist/databases/postgres/commands/postgres-create.command.js

@@ -1,23 +1,24 @@
 import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
-import { randomUUID } from 'crypto';
 import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
 export async function create(client, pluralResourceName, entity) {
     try {
-        entity._id = entity._id ?? randomUUID().toString();
+        delete entity._id;
         const { columns, values } = columnsAndValuesFromEntity(entity);
         const placeholders = columns.map((_, index) => `$${index + 1}`).join(', ');
         const query = `
             INSERT INTO "${pluralResourceName}" (${columns.join(', ')})
             VALUES (${placeholders})
-            RETURNING _id
+            RETURNING *
         `;
         const result = await client.query(query, values);
         if (result.rows.length === 0) {
             throw new BadRequestError(`Error creating ${pluralResourceName}: No row returned`);
         }
+        const insertedRow = result.rows[0];
+        const insertedId = insertedRow._id;
         return {
-            insertedId: entity._id,
-            entity: entity
+            insertedId: insertedId,
+            entity: insertedRow
         };
     }
     catch (err) {

package/dist/databases/postgres/commands/postgres-delete-by-id.command.d.ts

@@ -1,3 +1,4 @@
 import { Client } from 'pg';
 import { DeleteResult } from "../../models/delete-result.js";
-export declare function deleteById(client: Client, id: string, pluralResourceName: string): Promise<DeleteResult>;
+import type { AppIdType } from '@loomcore/common/types';
+export declare function deleteById(client: Client, id: AppIdType, pluralResourceName: string): Promise<DeleteResult>;

package/dist/databases/postgres/commands/postgres-full-update-by-id.command.d.ts

@@ -1,4 +1,5 @@
 import { Client } from 'pg';
 import { Operation } from "../../operations/operation.js";
 import { IEntity } from '@loomcore/common/models';
-export declare function fullUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+import type { AppIdType } from '@loomcore/common/types';
+export declare function fullUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;

package/dist/databases/postgres/commands/postgres-partial-update-by-id.command.d.ts

@@ -1,4 +1,5 @@
 import { Client } from 'pg';
 import { Operation } from "../../operations/operation.js";
 import { IEntity } from '@loomcore/common/models';
-export declare function partialUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+import type { AppIdType } from '@loomcore/common/types';
+export declare function partialUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;

package/dist/databases/postgres/migrations/__tests__/test-migration-helper.d.ts

@@ -0,0 +1,4 @@
+import { Pool } from 'pg';
+import { IBaseApiConfig } from '../../../../models/base-api-config.interface.js';
+export declare function runInitialSchemaMigrations(pool: Pool, config: IBaseApiConfig): Promise<void>;
+export declare function runTestSchemaMigrations(pool: Pool, config: IBaseApiConfig): Promise<void>;

package/dist/databases/postgres/migrations/__tests__/test-migration-helper.js

@@ -0,0 +1,67 @@
+import { Umzug } from 'umzug';
+import { getPostgresInitialSchema } from '../postgres-initial-schema.js';
+import { getPostgresTestSchema } from '../../../../__tests__/postgres-test-migrations/postgres-test-schema.js';
+export async function runInitialSchemaMigrations(pool, config) {
+    const initialSchema = getPostgresInitialSchema(config);
+    const umzug = new Umzug({
+        migrations: async () => {
+            return initialSchema.map(m => ({
+                name: m.name,
+                up: async () => {
+                    await m.up({ context: pool });
+                },
+                down: async () => {
+                    await m.down({ context: pool });
+                }
+            }));
+        },
+        context: pool,
+        storage: {
+            async executed({ context }) {
+                await context.query(`CREATE TABLE IF NOT EXISTS migrations (name text)`);
+                const result = await context.query(`SELECT name FROM migrations`);
+                return result.rows.map((r) => r.name);
+            },
+            async logMigration({ name, context }) {
+                await context.query(`INSERT INTO migrations (name) VALUES ($1)`, [name]);
+            },
+            async unlogMigration({ name, context }) {
+                await context.query(`DELETE FROM migrations WHERE name = $1`, [name]);
+            }
+        },
+        logger: undefined,
+    });
+    await umzug.up();
+}
+export async function runTestSchemaMigrations(pool, config) {
+    const testSchema = getPostgresTestSchema(config);
+    const umzug = new Umzug({
+        migrations: async () => {
+            return testSchema.map(m => ({
+                name: m.name,
+                up: async () => {
+                    await m.up({ context: pool });
+                },
+                down: async () => {
+                    await m.down({ context: pool });
+                }
+            }));
+        },
+        context: pool,
+        storage: {
+            async executed({ context }) {
+                await context.query(`CREATE TABLE IF NOT EXISTS migrations (name text)`);
+                const result = await context.query(`SELECT name FROM migrations`);
+                return result.rows.map((r) => r.name);
+            },
+            async logMigration({ name, context }) {
+                await context.query(`INSERT INTO migrations (name) VALUES ($1)`, [name]);
+            },
+            async unlogMigration({ name, context }) {
+                await context.query(`DELETE FROM migrations WHERE name = $1`, [name]);
+            }
+        },
+        logger: undefined,
+    });
+    await umzug.up();
+}

package/dist/databases/postgres/migrations/index.d.ts

@@ -1,2 +1 @@
-export * from './migration.interface.js';
-export * from './database-builder.js';
+export * from './postgres-initial-schema.js';

package/dist/databases/postgres/migrations/index.js

@@ -1,2 +1 @@
-export * from './migration.interface.js';
-export * from './database-builder.js';
+export * from './postgres-initial-schema.js';

package/dist/databases/postgres/migrations/{postgres-foundational.d.ts → postgres-initial-schema.d.ts}

@@ -9,4 +9,4 @@ export interface SyntheticMigration {
         context: Pool;
     }) => Promise<void>;
 }
-export declare const getPostgresFoundational: (config: IBaseApiConfig) => SyntheticMigration[];
+export declare const getPostgresInitialSchema: (config: IBaseApiConfig) => SyntheticMigration[];