@loomcore/api 0.1.51 → 0.1.53

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

@@ -8,29 +8,29 @@ export class CreateProductsTableMigration {
     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)
-                )
+            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);
+            await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
         }
         catch (error) {
@@ -40,16 +40,16 @@ export class CreateProductsTableMigration {
     }
     async revert() {
         try {
-            await this.client.query(`
-                DROP TABLE "products";
+            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}';
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
             `);
         }
         catch (error) {

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

@@ -8,28 +8,28 @@ export class CreateTestItemsTableMigration {
     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)
-                )
+            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);
+            await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
         }
         catch (error) {
@@ -39,16 +39,16 @@ export class CreateTestItemsTableMigration {
     }
     async revert() {
         try {
-            await this.client.query(`
-                DROP TABLE "testItems";
+            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}';
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
             `);
         }
         catch (error) {

package/dist/__tests__/postgres.test-database.js

@@ -39,9 +39,9 @@ export class TestPostgresDatabase {
     }
     async createIndexes(client) {
         try {
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS email_index ON users (LOWER(email));
-        CREATE UNIQUE INDEX IF NOT EXISTS email_unique_index ON users (LOWER(email));
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS email_index ON users (LOWER(email));
+        CREATE UNIQUE INDEX IF NOT EXISTS email_unique_index ON users (LOWER(email));
       `);
         }
         catch (error) {
@@ -52,11 +52,11 @@ export class TestPostgresDatabase {
         if (!this.postgresClient) {
             throw new Error('Database not initialized');
         }
-        const result = await this.postgresClient.query(`
-      SELECT "table_name" 
-      FROM information_schema.tables 
-      WHERE "table_schema" = 'public'
-      AND "table_type" = 'BASE TABLE'
+        const result = await this.postgresClient.query(`
+      SELECT "table_name" 
+      FROM information_schema.tables 
+      WHERE "table_schema" = 'public'
+      AND "table_type" = 'BASE TABLE'
     `);
         result.rows.forEach(async (row) => {
             await this.postgresClient?.query(`TRUNCATE TABLE "${row.table_name}" RESTART IDENTITY CASCADE`);

package/dist/databases/migrations/migration-runner.d.ts

@@ -1,5 +1,6 @@
 import { IBaseApiConfig } from '../../models/base-api-config.interface.js';
 export declare class MigrationRunner {
+    private config;
     private dbType;
     private dbUrl;
     private migrationsDir;
@@ -9,8 +10,9 @@ export declare class MigrationRunner {
     private getTimestamp;
     private parseSql;
     private getMigrator;
+    private loadFileMigrations;
     private wipeDatabase;
-    run(command: 'up' | 'down' | 'reset', target?: string): Promise<void>;
+    run(command?: 'up' | 'down' | 'reset', target?: string): Promise<void>;
     private closeConnection;
     create(name: string): Promise<void>;
 }

package/dist/databases/migrations/migration-runner.js

@@ -5,13 +5,17 @@ import fs from 'fs';
 import path from 'path';
 import { buildMongoUrl } from '../mongo-db/utils/build-mongo-url.util.js';
 import { buildPostgresUrl } from '../postgres/utils/build-postgres-url.util.js';
+import { getPostgresFoundational } from '../postgres/migrations/postgres-foundational.js';
+import { getMongoFoundational } from '../mongo-db/migrations/mongo-foundational.js';
 export class MigrationRunner {
+    config;
     dbType;
     dbUrl;
     migrationsDir;
     primaryTimezone;
     dbConnection;
     constructor(config) {
+        this.config = config;
         this.dbType = config.app.dbType || 'mongodb';
         this.dbUrl = this.dbType === 'postgres' ? buildPostgresUrl(config) : buildMongoUrl(config);
         this.migrationsDir = path.join(process.cwd(), 'database', 'migrations');
@@ -50,26 +54,21 @@ export class MigrationRunner {
         if (this.dbType === 'postgres') {
             const pool = new Pool({ connectionString: this.dbUrl });
             this.dbConnection = pool;
-            const globPattern = path.join(this.migrationsDir, '*.sql').replace(/\\/g, '/');
-            console.log(`🔎 Looking for migrations in: ${globPattern}`);
             return new Umzug({
-                migrations: {
-                    glob: globPattern,
-                    resolve: ({ name, path: filePath, context }) => {
-                        const content = fs.readFileSync(filePath, 'utf8');
-                        const { up, down } = this.parseSql(name, content);
-                        return {
-                            name,
-                            up: async () => {
-                                console.log(`   Running SQL for ${name}...`);
-                                await context.query(up);
-                            },
-                            down: async () => {
-                                console.log(`   Running Undo SQL for ${name}...`);
-                                await context.query(down);
-                            }
-                        };
-                    }
+                migrations: async () => {
+                    const foundationals = getPostgresFoundational(this.config).map(m => ({
+                        name: m.name,
+                        up: async () => {
+                            console.log(`   Running [LIBRARY] ${m.name}...`);
+                            await m.up({ context: pool });
+                        },
+                        down: async () => {
+                            console.log(`   Running [LIBRARY] Undo ${m.name}...`);
+                            await m.down({ context: pool });
+                        }
+                    }));
+                    const fileMigrations = this.loadFileMigrations(this.migrationsDir, 'sql', pool);
+                    return [...foundationals, ...fileMigrations].sort((a, b) => a.name.localeCompare(b.name));
                 },
                 context: pool,
                 storage: {
@@ -95,7 +94,21 @@ export class MigrationRunner {
             const globPattern = path.join(this.migrationsDir, '*.ts').replace(/\\/g, '/');
             console.log(`🔎 Looking for migrations in: ${globPattern}`);
             return new Umzug({
-                migrations: { glob: globPattern },
+                migrations: async () => {
+                    const foundationals = getMongoFoundational(this.config).map(m => ({
+                        name: m.name,
+                        up: async () => {
+                            console.log(`   Running [LIBRARY] ${m.name}...`);
+                            await m.up({ context: db });
+                        },
+                        down: async () => {
+                            console.log(`   Running [LIBRARY] Undo ${m.name}...`);
+                            await m.down({ context: db });
+                        }
+                    }));
+                    const fileMigrations = this.loadFileMigrations(this.migrationsDir, 'ts', db);
+                    return [...foundationals, ...fileMigrations].sort((a, b) => a.name.localeCompare(b.name));
+                },
                 context: db,
                 storage: new MongoDBStorage({ collection: db.collection('migrations') }),
                 logger: console,
@@ -103,6 +116,41 @@ export class MigrationRunner {
         }
         throw new Error(`Unsupported DB_TYPE: ${this.dbType}`);
     }
+    loadFileMigrations(dir, extension, context) {
+        return fs.readdirSync(dir)
+            .filter(f => f.endsWith(`.${extension}`))
+            .map(f => {
+            const fullPath = path.join(dir, f);
+            if (extension === 'sql') {
+                const content = fs.readFileSync(fullPath, 'utf8');
+                const { up, down } = this.parseSql(f, content);
+                return {
+                    name: f,
+                    up: async () => {
+                        console.log(`   Running [FILE] ${f}...`);
+                        await context.query(up);
+                    },
+                    down: async () => {
+                        console.log(`   Running [FILE] Undo ${f}...`);
+                        await context.query(down);
+                    }
+                };
+            }
+            else {
+                return {
+                    name: f,
+                    up: async () => {
+                        const mod = await import(fullPath);
+                        await mod.up({ context });
+                    },
+                    down: async () => {
+                        const mod = await import(fullPath);
+                        await mod.down({ context });
+                    }
+                };
+            }
+        });
+    }
     async wipeDatabase() {
         console.log(`⚠️  Wiping ${this.dbType} database...`);
         if (this.dbType === 'postgres') {
@@ -121,7 +169,7 @@ export class MigrationRunner {
         }
         console.log('✅ Database wiped.');
     }
-    async run(command, target) {
+    async run(command = 'up', target) {
         try {
             if (command === 'reset') {
                 await this.wipeDatabase();
@@ -189,31 +237,31 @@ export class MigrationRunner {
         let content = '';
         if (this.dbType === 'postgres') {
             extension = 'sql';
-            content = `-- Migration: ${safeName}
--- Created: ${new Date().toISOString()}
-
--- up
--- Write your CREATE/ALTER statements here...
-
-
--- down
--- Write your DROP/UNDO statements here...
+            content = `-- Migration: ${safeName}
+-- Created: ${new Date().toISOString()}
+
+-- up
+-- Write your CREATE/ALTER statements here...
+
+
+-- down
+-- Write your DROP/UNDO statements here...
 `;
         }
         else {
             extension = 'ts';
-            content = `import { Db } from 'mongodb';
-
-// Migration: ${safeName}
-// Created: ${new Date().toISOString()}
-
-export const up = async ({ context: db }: { context: Db }) => {
-  // await db.collection('...')....
-};
-
-export const down = async ({ context: db }: { context: Db }) => {
-  // await db.collection('...')....
-};
+            content = `import { Db } from 'mongodb';
+
+// Migration: ${safeName}
+// Created: ${new Date().toISOString()}
+
+export const up = async ({ context: db }: { context: Db }) => {
+  // await db.collection('...')....
+};
+
+export const down = async ({ context: db }: { context: Db }) => {
+  // await db.collection('...')....
+};
 `;
         }
         const fullPath = path.join(this.migrationsDir, `${filename}.${extension}`);

package/dist/databases/mongo-db/migrations/mongo-foundational.d.ts

@@ -0,0 +1,12 @@
+import { Db } from 'mongodb';
+import { IBaseApiConfig } from '../../../models/base-api-config.interface.js';
+export interface SyntheticMigration {
+    name: string;
+    up: (context: {
+        context: Db;
+    }) => Promise<void>;
+    down: (context: {
+        context: Db;
+    }) => Promise<void>;
+}
+export declare const getMongoFoundational: (config: IBaseApiConfig) => SyntheticMigration[];

package/dist/databases/mongo-db/migrations/mongo-foundational.js

@@ -0,0 +1,30 @@
+export const getMongoFoundational = (config) => {
+    const migrations = [];
+    const isMultiTenant = config.app.isMultiTenant === true;
+    migrations.push({
+        name: '00000000000001_base-users',
+        up: async ({ context: db }) => {
+            await db.createCollection('users');
+            await db.collection('users').createIndex({ email: 1 }, { unique: true });
+            if (isMultiTenant) {
+                await db.collection('users').createIndex({ _orgId: 1 });
+            }
+        },
+        down: async ({ context: db }) => {
+            await db.collection('users').drop();
+        }
+    });
+    if (isMultiTenant) {
+        migrations.push({
+            name: '00000000000002_base-organizations',
+            up: async ({ context: db }) => {
+                await db.createCollection('organizations');
+                await db.collection('organizations').createIndex({ name: 1 });
+            },
+            down: async ({ context: db }) => {
+                await db.collection('organizations').drop();
+            }
+        });
+    }
+    return migrations;
+};

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

@@ -26,10 +26,10 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
             const setClause = columns.map((col, index) => `${col} = $${index + 1}`).join(', ');
             queryObject.filters._id = { eq: _id };
             const { whereClause } = buildWhereClause(queryObject, values);
-            const query = `
-                UPDATE "${pluralResourceName}"
-                SET ${setClause}
-                ${whereClause}
+            const query = `
+                UPDATE "${pluralResourceName}"
+                SET ${setClause}
+                ${whereClause}
             `;
             await client.query(query, values);
         }
@@ -39,9 +39,9 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
         const tablePrefix = hasJoins ? pluralResourceName : undefined;
         queryObject.filters._id = { in: entityIds };
         const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
-        const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
-            ${whereClause}
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            ${whereClause}
         `;
         const result = await client.query(selectQuery, values);
         return result.rows;

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

@@ -12,12 +12,12 @@ export async function createMany(client, pluralResourceName, entities) {
             entity._id = entity._id ?? randomUUID().toString();
             return entity;
         });
-        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
+        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}`);
@@ -39,10 +39,10 @@ export async function createMany(client, pluralResourceName, entities) {
             valueClauses.push(`(${placeholders})`);
             allValues.push(...values);
         });
-        const query = `
-            INSERT INTO "${pluralResourceName}" (${tableColumns.rows.map(column => `"${column.column_name}"`).join(', ')})
-            VALUES ${valueClauses.join(', ')}
-            RETURNING _id
+        const query = `
+            INSERT INTO "${pluralResourceName}" (${tableColumns.rows.map(column => `"${column.column_name}"`).join(', ')})
+            VALUES ${valueClauses.join(', ')}
+            RETURNING _id
         `;
         const result = await client.query(query, allValues);
         if (result.rows.length !== entitiesWithIds.length) {

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

@@ -6,10 +6,10 @@ export async function create(client, pluralResourceName, entity) {
         entity._id = entity._id ?? randomUUID().toString();
         const { columns, values } = columnsAndValuesFromEntity(entity);
         const placeholders = columns.map((_, index) => `$${index + 1}`).join(', ');
-        const query = `
-            INSERT INTO "${pluralResourceName}" (${columns.join(', ')})
-            VALUES (${placeholders})
-            RETURNING _id
+        const query = `
+            INSERT INTO "${pluralResourceName}" (${columns.join(', ')})
+            VALUES (${placeholders})
+            RETURNING _id
         `;
         const result = await client.query(query, values);
         if (result.rows.length === 0) {

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

@@ -2,12 +2,12 @@ import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
 export async function fullUpdateById(client, operations, id, entity, pluralResourceName) {
     try {
-        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
+        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}`);
@@ -40,19 +40,19 @@ export async function fullUpdateById(client, operations, id, entity, pluralResou
             throw new BadRequestError('Cannot perform full update with no fields to update');
         }
         const setClause = updateColumns.join(', ');
-        const query = `
-            UPDATE "${pluralResourceName}"
-            SET ${setClause}
-            WHERE "_id" = $${paramIndex}
+        const query = `
+            UPDATE "${pluralResourceName}"
+            SET ${setClause}
+            WHERE "_id" = $${paramIndex}
         `;
         const result = await client.query(query, [...updateValues, id]);
         if (result.rowCount === 0) {
             throw new IdNotFoundError();
         }
         const joinClauses = buildJoinClauses(operations);
-        const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
-            WHERE "_id" = $1 LIMIT 1
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            WHERE "_id" = $1 LIMIT 1
         `;
         const selectResult = await client.query(selectQuery, [id]);
         if (selectResult.rows.length === 0) {

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

@@ -10,19 +10,19 @@ export async function partialUpdateById(client, operations, id, entity, pluralRe
             throw new BadRequestError('Cannot perform partial update with no fields to update');
         }
         const setClause = updateColumns.map((col, index) => `${col} = $${index + 1}`).join(', ');
-        const query = `
-            UPDATE "${pluralResourceName}"
-            SET ${setClause}
-            WHERE "_id" = $${updateValues.length + 1}
+        const query = `
+            UPDATE "${pluralResourceName}"
+            SET ${setClause}
+            WHERE "_id" = $${updateValues.length + 1}
         `;
         const result = await client.query(query, [...updateValues, id]);
         if (result.rowCount === 0) {
             throw new IdNotFoundError();
         }
         const joinClauses = buildJoinClauses(operations);
-        const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
-            WHERE "_id" = $1 LIMIT 1
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            WHERE "_id" = $1 LIMIT 1
         `;
         const selectResult = await client.query(selectQuery, [id]);
         if (selectResult.rows.length === 0) {

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

@@ -17,10 +17,10 @@ export async function update(client, queryObject, entity, operations, pluralReso
             const originalIndex = parseInt(num, 10);
             return `$${originalIndex + updateValues.length}`;
         });
-        const updateQuery = `
-            UPDATE "${pluralResourceName}"
-            SET ${setClause}
-            ${whereClauseWithAdjustedParams}
+        const updateQuery = `
+            UPDATE "${pluralResourceName}"
+            SET ${setClause}
+            ${whereClauseWithAdjustedParams}
         `;
         const allUpdateValues = [...updateValues, ...whereValues];
         const result = await client.query(updateQuery, allUpdateValues);
@@ -29,9 +29,9 @@ export async function update(client, queryObject, entity, operations, pluralReso
         }
         const joinClauses = buildJoinClauses(operations);
         const orderByClause = buildOrderByClause(queryObject);
-        const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
-            ${whereClause} ${orderByClause}
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            ${whereClause} ${orderByClause}
         `.trim();
         const selectResult = await client.query(selectQuery, whereValues);
         return selectResult.rows;

package/dist/databases/postgres/migrations/001-create-migrations-table.migration.js

@@ -12,18 +12,18 @@ export class CreateMigrationTableMigration {
             await this.client.query('BEGIN');
             const tableExists = await doesTableExist(this.client, 'migrations');
             if (!tableExists) {
-                await this.client.query(`
-                    CREATE TABLE "migrations" (
-                        "_id" VARCHAR(255) PRIMARY KEY,
-                        "index" INTEGER NOT NULL UNIQUE,
-                        "hasRun" BOOLEAN NOT NULL,
-                        "reverted" BOOLEAN NOT NULL
-                    )
+                await this.client.query(`
+                    CREATE TABLE "migrations" (
+                        "_id" VARCHAR(255) PRIMARY KEY,
+                        "index" INTEGER NOT NULL UNIQUE,
+                        "hasRun" BOOLEAN NOT NULL,
+                        "reverted" BOOLEAN NOT NULL
+                    )
                 `);
             }
-            const result = await this.client.query(`
-                INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
-                VALUES ('${_id}', ${this.index}, TRUE, FALSE);
+            const result = await this.client.query(`
+                INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
             if (result.rowCount === 0) {
                 await this.client.query('ROLLBACK');
@@ -39,8 +39,8 @@ export class CreateMigrationTableMigration {
     }
     async revert() {
         try {
-            await this.client.query(`
-            DROP TABLE "migrations";
+            await this.client.query(`
+            DROP TABLE "migrations";
         `);
         }
         catch (error) {