@loomcore/api 0.1.43 → 0.1.47

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/db-type.type.d.ts

@@ -0,0 +1 @@
+export type DbType = 'postgres' | 'mongodb';

package/dist/databases/db-type.type.js

@@ -0,0 +1 @@
+export {};

package/dist/databases/index.d.ts

@@ -1,5 +1,6 @@
-export * from './mongo-db/index.js';
-export * from './postgres/index.js';
+export * from './db-type.type.js';
+export * from './migrations/migration-runner.js';
 export * from './models/index.js';
+export * from './mongo-db/index.js';
 export * from './operations/index.js';
-export * from './migrations/migration-runner.js';
+export * from './postgres/index.js';

package/dist/databases/index.js

@@ -1,5 +1,6 @@
-export * from './mongo-db/index.js';
-export * from './postgres/index.js';
+export * from './db-type.type.js';
+export * from './migrations/migration-runner.js';
 export * from './models/index.js';
+export * from './mongo-db/index.js';
 export * from './operations/index.js';
-export * from './migrations/migration-runner.js';
+export * from './postgres/index.js';

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

@@ -1,16 +1,14 @@
-export type DbType = 'postgres' | 'mongo';
-export interface MigrationConfig {
-    dbType: DbType;
-    dbUrl: string;
-    migrationsDir: string;
-}
+import { IBaseApiConfig } from '../../models/base-api-config.interface.js';
 export declare class MigrationRunner {
-    private config;
+    private dbType;
+    private dbUrl;
+    private migrationsDir;
     private mongoClient;
-    constructor(config: MigrationConfig);
+    constructor(config: IBaseApiConfig);
     private parseSql;
     private getMigrator;
     private wipeDatabase;
     run(command: 'up' | 'down' | 'reset'): Promise<void>;
     private closeConnection;
+    create(name: string): Promise<void>;
 }

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

@@ -3,11 +3,22 @@ import { Pool } from 'pg';
 import { MongoClient } from 'mongodb';
 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';
+const getTimestamp = () => {
+    const now = new Date();
+    return now.toISOString().replace(/[-T:.Z]/g, '').slice(0, 14);
+};
 export class MigrationRunner {
-    config;
+    dbType;
+    dbUrl;
+    migrationsDir;
     mongoClient = null;
     constructor(config) {
-        this.config = config;
+        this.dbType = config.app.dbType || 'mongodb';
+        console.log('config', config);
+        this.dbUrl = this.dbType === 'postgres' ? buildPostgresUrl(config) : buildMongoUrl(config);
+        this.migrationsDir = path.join(process.cwd(), 'database', 'migrations');
     }
     parseSql(content) {
         const upMatch = content.match(/--\s*up\s([\s\S]+?)(?=--\s*down|$)/i);
@@ -18,12 +29,11 @@ export class MigrationRunner {
         };
     }
     async getMigrator() {
-        const { dbType, dbUrl, migrationsDir } = this.config;
-        if (dbType === 'postgres') {
-            const pool = new Pool({ connectionString: dbUrl });
+        if (this.dbType === 'postgres') {
+            const pool = new Pool({ connectionString: this.dbUrl });
             return new Umzug({
                 migrations: {
-                    glob: path.join(migrationsDir, '*.sql'),
+                    glob: path.join(this.migrationsDir, '*.sql'),
                     resolve: ({ name, path: filePath, context }) => {
                         const content = fs.readFileSync(filePath, 'utf8');
                         const { up, down } = this.parseSql(content);
@@ -51,24 +61,23 @@ export class MigrationRunner {
                 logger: console,
             });
         }
-        else if (dbType === 'mongo') {
-            const client = await MongoClient.connect(dbUrl);
+        else if (this.dbType === 'mongodb') {
+            const client = await MongoClient.connect(this.dbUrl);
             this.mongoClient = client;
             const db = client.db();
             return new Umzug({
-                migrations: { glob: path.join(migrationsDir, '*.ts') },
+                migrations: { glob: path.join(this.migrationsDir, '*.ts') },
                 context: db,
                 storage: new MongoDBStorage({ collection: db.collection('migrations') }),
                 logger: console,
             });
         }
-        throw new Error(`Unsupported DB_TYPE: ${dbType}`);
+        throw new Error(`Unsupported DB_TYPE: ${this.dbType}`);
     }
     async wipeDatabase() {
-        const { dbType, dbUrl } = this.config;
-        console.log(`⚠️  Wiping ${dbType} database...`);
-        if (dbType === 'postgres') {
-            const pool = new Pool({ connectionString: dbUrl });
+        console.log(`⚠️  Wiping ${this.dbType} database...`);
+        if (this.dbType === 'postgres') {
+            const pool = new Pool({ connectionString: this.dbUrl });
             try {
                 await pool.query('DROP SCHEMA public CASCADE; CREATE SCHEMA public;');
             }
@@ -76,8 +85,8 @@ export class MigrationRunner {
                 await pool.end();
             }
         }
-        else if (dbType === 'mongo') {
-            const client = await MongoClient.connect(dbUrl);
+        else if (this.dbType === 'mongodb') {
+            const client = await MongoClient.connect(this.dbUrl);
             await client.db().dropDatabase();
             await client.close();
         }
@@ -113,12 +122,56 @@ export class MigrationRunner {
         }
     }
     async closeConnection(migrator) {
-        if (this.config.dbType === 'postgres') {
+        if (this.dbType === 'postgres') {
             await migrator.context.end();
         }
-        else if (this.config.dbType === 'mongo' && this.mongoClient) {
+        else if (this.dbType === 'mongodb' && this.mongoClient) {
             await this.mongoClient.close();
             this.mongoClient = null;
         }
     }
+    async create(name) {
+        if (!name) {
+            throw new Error('Migration name is required');
+        }
+        const safeName = name.toLowerCase().replace(/[^a-z0-9]+/g, '_');
+        const filename = `${getTimestamp()}_${safeName}`;
+        let extension = '';
+        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...
+`;
+        }
+        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('...')....
+};
+`;
+        }
+        const fullPath = path.join(this.migrationsDir, `${filename}.${extension}`);
+        if (!fs.existsSync(this.migrationsDir)) {
+            fs.mkdirSync(this.migrationsDir, { recursive: true });
+        }
+        fs.writeFileSync(fullPath, content);
+        console.log(`✅ Created migration:\n   ${fullPath}`);
+    }
 }

package/dist/databases/mongo-db/utils/build-mongo-url.util.d.ts

@@ -0,0 +1,2 @@
+import { IBaseApiConfig } from "../../../models/base-api-config.interface.js";
+export declare function buildMongoUrl(config: IBaseApiConfig): string;

package/dist/databases/mongo-db/utils/build-mongo-url.util.js

@@ -0,0 +1,13 @@
+export function buildMongoUrl(config) {
+    const { database } = config;
+    if (!database) {
+        throw new Error("Database configuration is required to build the MongoDB URL.");
+    }
+    const { user, password, host, port, name } = database;
+    if (!user || !password || !host || !port || !name) {
+        throw new Error("Database configuration must include user, password, host, port, and name to build the MongoDB URL.");
+    }
+    const encodedUser = encodeURIComponent(user);
+    const encodedPassword = encodeURIComponent(password);
+    return `mongodb://${encodedUser}:${encodedPassword}@${host}:${port}/${name}`;
+}

package/dist/databases/mongo-db/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './build-find-options.util.js';
+export * from './build-mongo-url.util.js';
 export * from './build-no-sql-match.util.js';
 export * from './convert-object-ids-to-strings.util.js';
 export * from './convert-operations-to-pipeline.util.js';

package/dist/databases/mongo-db/utils/index.js

@@ -1,4 +1,5 @@
 export * from './build-find-options.util.js';
+export * from './build-mongo-url.util.js';
 export * from './build-no-sql-match.util.js';
 export * from './convert-object-ids-to-strings.util.js';
 export * from './convert-operations-to-pipeline.util.js';

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) {