@loomcore/api 0.1.22 → 0.1.23

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

@@ -8,12 +8,12 @@ export class CreateCategoriesTableMigration {
     async execute(_orgId) {
         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
-                )
+            await this.client.query(`
+                CREATE TABLE "categories" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "name" VARCHAR(255) NOT NULL
+                )
             `);
         }
         catch (error) {
@@ -21,8 +21,8 @@ export class CreateCategoriesTableMigration {
         }
         if (_orgId) {
             try {
-                await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
             catch (error) {
@@ -31,8 +31,8 @@ export class CreateCategoriesTableMigration {
         }
         else {
             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) {
@@ -43,16 +43,16 @@ export class CreateCategoriesTableMigration {
     }
     async revert(_orgId) {
         try {
-            await this.client.query(`
-                DROP TABLE "categories";
+            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}' AND "_orgId" = '${_orgId}';
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
         }
         catch (error) {

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

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

package/dist/__tests__/postgres-test-migrations/004-create-test-users-table.migration.js

@@ -8,25 +8,25 @@ export class CreateTestUsersTableMigration {
     async execute(_orgId) {
         const _id = randomUUID().toString();
         try {
-            await this.client.query(`
-                CREATE TABLE "testUsers" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "email" VARCHAR(255) NOT NULL,
-                    "password" VARCHAR(255) NOT NULL,
-                    "firstName" VARCHAR(255),
-                    "lastName" VARCHAR(255),
-                    "displayName" VARCHAR(255),
-                    "roles" TEXT[],
-                    "_lastLoggedIn" TIMESTAMP,
-                    "_lastPasswordChange" 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 "testUsers" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "email" VARCHAR(255) NOT NULL,
+                    "password" VARCHAR(255) NOT NULL,
+                    "firstName" VARCHAR(255),
+                    "lastName" VARCHAR(255),
+                    "displayName" VARCHAR(255),
+                    "roles" TEXT[],
+                    "_lastLoggedIn" TIMESTAMP,
+                    "_lastPasswordChange" 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) {
@@ -34,8 +34,8 @@ export class CreateTestUsersTableMigration {
         }
         if (_orgId) {
             try {
-                await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
             catch (error) {
@@ -44,8 +44,8 @@ export class CreateTestUsersTableMigration {
         }
         else {
             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) {
@@ -56,16 +56,16 @@ export class CreateTestUsersTableMigration {
     }
     async revert(_orgId) {
         try {
-            await this.client.query(`
-                DROP TABLE "testUsers";
+            await this.client.query(`
+                DROP TABLE "testUsers";
             `);
         }
         catch (error) {
             return { success: false, error: new Error(`Error dropping test users table: ${error.message}`) };
         }
         try {
-            await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
         }
         catch (error) {

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

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

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

@@ -51,9 +51,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) {
@@ -64,11 +64,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

@@ -0,0 +1,15 @@
+export type DbType = 'postgres' | 'mongo';
+export interface MigrationConfig {
+    dbType: DbType;
+    dbUrl: string;
+    migrationsDir: string;
+}
+export declare class MigrationRunner {
+    private config;
+    constructor(config: MigrationConfig);
+    private parseSql;
+    private getMigrator;
+    private wipeDatabase;
+    run(command: 'up' | 'down' | 'reset'): Promise<void>;
+    private closeConnection;
+}

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

@@ -0,0 +1,118 @@
+import { Umzug, MongoDBStorage } from 'umzug';
+import { Pool } from 'pg';
+import { MongoClient } from 'mongodb';
+import fs from 'fs';
+import path from 'path';
+export class MigrationRunner {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    parseSql(content) {
+        const upMatch = content.match(/--\s*up\s([\s\S]+?)(?=--\s*down|$)/i);
+        const downMatch = content.match(/--\s*down\s([\s\S]+)/i);
+        return {
+            up: upMatch ? upMatch[1].trim() : '',
+            down: downMatch ? downMatch[1].trim() : ''
+        };
+    }
+    async getMigrator() {
+        const { dbType, dbUrl, migrationsDir } = this.config;
+        if (dbType === 'postgres') {
+            const pool = new Pool({ connectionString: dbUrl });
+            return new Umzug({
+                migrations: {
+                    glob: path.join(migrationsDir, '*.sql'),
+                    resolve: ({ name, path: filePath, context }) => {
+                        const content = fs.readFileSync(filePath, 'utf8');
+                        const { up, down } = this.parseSql(content);
+                        return {
+                            name,
+                            up: async () => context.query(up),
+                            down: async () => context.query(down)
+                        };
+                    }
+                },
+                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: console,
+            });
+        }
+        else if (dbType === 'mongo') {
+            const client = await MongoClient.connect(dbUrl);
+            const db = client.db();
+            return new Umzug({
+                migrations: { glob: path.join(migrationsDir, '*.ts') },
+                context: db,
+                storage: new MongoDBStorage({ collection: db.collection('migrations') }),
+                logger: console,
+            });
+        }
+        throw new Error(`Unsupported DB_TYPE: ${dbType}`);
+    }
+    async wipeDatabase() {
+        const { dbType, dbUrl } = this.config;
+        console.log(`⚠️  Wiping ${dbType} database...`);
+        if (dbType === 'postgres') {
+            const pool = new Pool({ connectionString: dbUrl });
+            try {
+                await pool.query('DROP SCHEMA public CASCADE; CREATE SCHEMA public;');
+            }
+            finally {
+                await pool.end();
+            }
+        }
+        else if (dbType === 'mongo') {
+            const client = await MongoClient.connect(dbUrl);
+            await client.db().dropDatabase();
+            await client.close();
+        }
+        console.log('✅ Database wiped.');
+    }
+    async run(command) {
+        try {
+            if (command === 'reset') {
+                await this.wipeDatabase();
+                console.log('🚀 Restarting migrations...');
+                const migrator = await this.getMigrator();
+                await migrator.up();
+                await this.closeConnection(migrator);
+                console.log('✅ Reset complete.');
+                return;
+            }
+            const migrator = await this.getMigrator();
+            switch (command) {
+                case 'up':
+                    await migrator.up();
+                    console.log('✅ Migrations up to date.');
+                    break;
+                case 'down':
+                    await migrator.down();
+                    console.log('✅ Reverted last migration.');
+                    break;
+            }
+            await this.closeConnection(migrator);
+        }
+        catch (err) {
+            console.error('❌ Migration failed:', err);
+            process.exit(1);
+        }
+    }
+    async closeConnection(migrator) {
+        if (this.config.dbType === 'postgres') {
+            await migrator.context.end();
+        }
+    }
+}

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;