@loomcore/api 0.2.42 → 0.2.45

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -1,25 +1,25 @@
-import { EmptyUserContext, getSystemUserContext, initializeSystemUserContext, isSystemUserContextInitialized, } from "@loomcore/common/models";
-import { OrganizationService } from "../../../services/index.js";
-import { passwordUtils } from "../../../utils/index.js";
-import { PostgresDatabase } from "../postgres.database.js";
+import { EmptyUserContext, getSystemUserContext, initializeSystemUserContext, isSystemUserContextInitialized, } from '@loomcore/common/models';
+import { OrganizationService } from '../../../services/index.js';
+import { passwordUtils } from '../../../utils/index.js';
+import { PostgresDatabase } from '../postgres.database.js';
 export const getPostgresInitialSchema = (dbConfig) => {
     const migrations = [];
     const isMultiTenant = dbConfig.app.isMultiTenant;
     if (isMultiTenant && !dbConfig.multiTenant) {
-        throw new Error("Multi-tenant configuration is enabled but multi-tenant configuration is not provided");
+        throw new Error('Multi-tenant configuration is enabled but multi-tenant configuration is not provided');
     }
     const isAuthEnabled = dbConfig.app.isAuthEnabled;
     const dbName = dbConfig.database.name.replace(/"/g, '""');
     migrations.push({
-        name: "00000000000001_system-configurations",
+        name: '00000000000001_system-configurations',
         up: async ({ context: pool }) => {
-            if (dbConfig.env === "test") {
+            if (dbConfig.env === 'test') {
                 return;
             }
             await pool.query(`ALTER DATABASE "${dbName}" SET statement_timeout = '60s'`);
         },
         down: async ({ context: pool }) => {
-            if (dbConfig.env === "test") {
+            if (dbConfig.env === 'test') {
                 return;
             }
             await pool.query(`ALTER DATABASE "${dbName}" RESET statement_timeout`);
@@ -27,7 +27,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
     });
     if (isMultiTenant) {
         migrations.push({
-            name: "00000000000002_schema-organizations",
+            name: '00000000000002_schema-organizations',
             up: async ({ context: pool }) => {
                 await pool.query(`
           CREATE TABLE IF NOT EXISTS "organizations" (
@@ -52,23 +52,23 @@ export const getPostgresInitialSchema = (dbConfig) => {
             },
         });
         migrations.push({
-            name: "00000000000002_schema-organizations-domains",
+            name: '00000000000002_schema-organizations-domains',
             up: async ({ context: pool }) => {
                 await pool.query(`
-				CREATE TABLE IF NOT EXISTS "organization_domains" (
-					"_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-					"organization_id" INTEGER NOT NULL,
-					"domain" VARCHAR(255) NOT NULL UNIQUE,
-					"_created" TIMESTAMPTZ NOT NULL,
-					"_createdBy" INTEGER NOT NULL,
-					"_updated" TIMESTAMPTZ,
-					"_updatedBy" INTEGER,
-					"_deleted" TIMESTAMPTZ,
-					"_deletedBy" INTEGER,
-					CONSTRAINT "fk_organization_domains_organization"
-					FOREIGN KEY("organization_id") REFERENCES "organizations"("_id") ON DELETE CASCADE
-				)
-				`);
+        CREATE TABLE IF NOT EXISTS "organization_domains" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          "organization_id" INTEGER NOT NULL,
+          "domain" VARCHAR(255) NOT NULL UNIQUE,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ,
+          "_updatedBy" INTEGER,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT "fk_organization_domains_organization"
+          FOREIGN KEY("organization_id") REFERENCES "organizations"("_id") ON DELETE CASCADE
+        )
+        `);
             },
             down: async ({ context: pool }) => {
                 await pool.query('DROP TABLE IF EXISTS "organization_domains"');
@@ -77,9 +77,9 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000003_schema-users",
+            name: '00000000000003_schema-users',
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : '';
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")'
                     : 'CONSTRAINT "uk_users_email" UNIQUE ("email")';
@@ -87,7 +87,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         CREATE TABLE IF NOT EXISTS "users"(
             "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
             ${orgColumnDef}
-          	"external_id" VARCHAR(255) UNIQUE,
+            "external_id" VARCHAR(255) UNIQUE,
             "email" VARCHAR(255) NOT NULL,
             "display_name" VARCHAR(255),
             "password" VARCHAR(255) NOT NULL,
@@ -112,9 +112,9 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000004_schema-refresh-tokens",
+            name: '00000000000004_schema-refresh-tokens',
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : '';
                 await pool.query(`
         CREATE TABLE IF NOT EXISTS "refresh_tokens"(
             "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -135,9 +135,9 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000005_schema-password-reset-tokens",
+            name: '00000000000005_schema-password-reset-tokens',
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : '';
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_passwordResetTokens_email" UNIQUE ("_orgId", "email")'
                     : 'CONSTRAINT "uk_passwordResetTokens_email" UNIQUE ("email")';
@@ -164,9 +164,9 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000006_schema-roles",
+            name: '00000000000006_schema-roles',
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : '';
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_roles_name" UNIQUE ("_orgId", "name")'
                     : 'CONSTRAINT "uk_roles_name" UNIQUE ("name")';
@@ -186,9 +186,9 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000007_schema-user-roles",
+            name: '00000000000007_schema-user-roles',
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : '';
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "user_id", "role_id")'
                     : 'CONSTRAINT "uk_user_roles" UNIQUE ("user_id", "role_id")';
@@ -216,9 +216,9 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000008_schema-features",
+            name: '00000000000008_schema-features',
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : '';
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_features" UNIQUE ("_orgId", "name")'
                     : 'CONSTRAINT "uk_features" UNIQUE ("name")';
@@ -238,9 +238,9 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000009_schema-authorizations",
+            name: '00000000000009_schema-authorizations',
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : '';
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "role_id", "feature_id")'
                     : 'CONSTRAINT "uk_authorizations" UNIQUE ("role_id", "feature_id")';
@@ -271,28 +271,28 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isMultiTenant) {
         migrations.push({
-            name: "00000000000010_data-meta-org",
+            name: '00000000000010_data-meta-org',
             up: async ({ context: pool }) => {
                 const result = await pool.query(`
-					INSERT INTO "organizations"("name", "code", "status", "is_meta_org", "_created", "_createdBy")
-					VALUES($1, $2, 1, true, NOW(), 0)
-					RETURNING "_id", "name", "code", "status", "is_meta_org", "_created", "_createdBy"
-					`, [
+          INSERT INTO "organizations"("name", "code", "status", "is_meta_org", "_created", "_createdBy")
+          VALUES($1, $2, 1, true, NOW(), 0)
+          RETURNING "_id", "name", "code", "status", "is_meta_org", "_created", "_createdBy"
+          `, [
                     dbConfig.multiTenant?.metaOrgName,
                     dbConfig.multiTenant?.metaOrgCode,
                 ]);
                 if (result.rowCount === 0) {
-                    throw new Error("Failed to create meta organization");
+                    throw new Error('Failed to create meta organization');
                 }
                 const metaOrg = result.rows[0];
                 const metaOrgDomains = dbConfig.multiTenant?.metaOrgDomains ?? [];
                 for (const domain of metaOrgDomains) {
                     await pool.query(`
-						INSERT INTO "organization_domains"("organization_id", "domain", "_created", "_createdBy")
-						VALUES($1, $2, NOW(), 0)
-						`, [metaOrg._id, domain]);
+            INSERT INTO "organization_domains"("organization_id", "domain", "_created", "_createdBy")
+            VALUES($1, $2, NOW(), 0)
+            `, [metaOrg._id, domain]);
                 }
-                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || "system@example.com", metaOrg);
+                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || 'system@example.com', metaOrg);
             },
             down: async ({ context: pool }) => {
                 await pool.query(`DELETE FROM "organizations" WHERE "is_meta_org" = TRUE`);
@@ -301,14 +301,14 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000011_data-admin-user",
+            name: '00000000000011_data-admin-user',
             up: async ({ context: pool }) => {
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
-                        ? "SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. " +
-                            "Please ensure metaOrgName and metaOrgCode are provided in your dbConfig."
-                        : "BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.";
-                    console.error("❌ Migration Error:", errorMessage);
+                        ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. ' +
+                            'Please ensure metaOrgName and metaOrgCode are provided in your dbConfig.'
+                        : 'BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.';
+                    console.error('❌ Migration Error:', errorMessage);
                     throw new Error(errorMessage);
                 }
                 const systemUserContext = getSystemUserContext();
@@ -321,11 +321,11 @@ export const getPostgresInitialSchema = (dbConfig) => {
                 try {
                     if (isMultiTenant) {
                         await client.query(`INSERT INTO "users"("_orgId", "email", "display_name", "password", "_created", "_createdBy")
-        				VALUES($1, $2, 'Admin User', $3, NOW(), 0)`, [orgId, email, hashedPassword]);
+                VALUES($1, $2, 'Admin User', $3, NOW(), 0)`, [orgId, email, hashedPassword]);
                     }
                     else {
                         await client.query(`INSERT INTO "users"("email", "display_name", "password", "_created", "_createdBy")
-        				VALUES($1, 'Admin User', $2, NOW(), 0)`, [email, hashedPassword]);
+                VALUES($1, 'Admin User', $2, NOW(), 0)`, [email, hashedPassword]);
                     }
                 }
                 finally {
@@ -343,7 +343,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000012_data-admin-authorizations",
+            name: '00000000000012_data-admin-authorizations',
             up: async ({ context: pool }) => {
                 const client = await pool.connect();
                 try {
@@ -353,16 +353,16 @@ export const getPostgresInitialSchema = (dbConfig) => {
                         ? await organizationService.getMetaOrg(EmptyUserContext)
                         : undefined;
                     if (isMultiTenant && !metaOrg) {
-                        throw new Error("Meta organization not found. Ensure meta-org migration ran successfully.");
+                        throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
                     }
                     const email = dbConfig.adminUser.email.toLowerCase();
                     const userResult = await client.query(`SELECT "_id" FROM "users" WHERE "email" = $1`, [email]);
                     const adminUserRow = userResult.rows[0];
                     if (!adminUserRow) {
-                        throw new Error("Admin user not found. Ensure admin-user migration ran successfully.");
+                        throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
                     }
                     const adminUserId = adminUserRow._id;
-                    await client.query("BEGIN");
+                    await client.query('BEGIN');
                     try {
                         const roleResult = isMultiTenant
                             ? await client.query(`
@@ -376,7 +376,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
                   RETURNING "_id"
           `);
                         if (roleResult.rowCount === 0) {
-                            throw new Error("Failed to create admin role");
+                            throw new Error('Failed to create admin role');
                         }
                         const roleId = roleResult.rows[0]._id;
                         const userRoleResult = isMultiTenant
@@ -389,7 +389,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         VALUES($1, $2, NOW(), 0)
           `, [adminUserId, roleId]);
                         if (userRoleResult.rowCount === 0) {
-                            throw new Error("Failed to create user role");
+                            throw new Error('Failed to create user role');
                         }
                         const featureResult = isMultiTenant
                             ? await client.query(`
@@ -403,7 +403,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
                   RETURNING "_id"
           `);
                         if (featureResult.rowCount === 0) {
-                            throw new Error("Failed to create admin feature");
+                            throw new Error('Failed to create admin feature');
                         }
                         const featureId = featureResult.rows[0]._id;
                         const authorizationResult = isMultiTenant
@@ -422,12 +422,12 @@ export const getPostgresInitialSchema = (dbConfig) => {
         VALUES($1, $2, NOW(), 0)
           `, [roleId, featureId]);
                         if (authorizationResult.rowCount === 0) {
-                            throw new Error("Failed to create admin authorization");
+                            throw new Error('Failed to create admin authorization');
                         }
-                        await client.query("COMMIT");
+                        await client.query('COMMIT');
                     }
                     catch (error) {
-                        await client.query("ROLLBACK");
+                        await client.query('ROLLBACK');
                         throw error;
                     }
                 }
@@ -445,7 +445,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
                         : undefined;
                     if (isMultiTenant && !metaOrg)
                         return;
-                    await client.query("BEGIN");
+                    await client.query('BEGIN');
                     try {
                         if (isMultiTenant) {
                             await client.query(`
@@ -505,10 +505,10 @@ export const getPostgresInitialSchema = (dbConfig) => {
                 WHERE "name" = 'admin'
           `);
                         }
-                        await client.query("COMMIT");
+                        await client.query('COMMIT');
                     }
                     catch (error) {
-                        await client.query("ROLLBACK");
+                        await client.query('ROLLBACK');
                         throw error;
                     }
                 }

package/dist/databases/postgres/postgres.database.d.ts

@@ -1,9 +1,9 @@
-import { IEntity, IModelSpec, IPagedResult, IQueryOptions } from "@loomcore/common/models";
-import type { AppIdType } from "@loomcore/common/types";
-import { TSchema } from "@sinclair/typebox";
-import { DeleteResult, IDatabase } from "../models/index.js";
-import { Operation } from "../operations/operation.js";
-import type { PostgresConnection } from "./postgres-connection.js";
+import { IEntity, IModelSpec, IPagedResult, IQueryOptions } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
+import { TSchema } from '@sinclair/typebox';
+import { DeleteResult, IDatabase } from '../models/index.js';
+import { Operation } from '../operations/operation.js';
+import type { PostgresConnection } from './postgres-connection.js';
 export declare class PostgresDatabase implements IDatabase {
     private connection;
     constructor(connection: PostgresConnection);

package/dist/databases/postgres/postgres.database.js

@@ -1,19 +1,19 @@
-import { batchUpdate as batchUpdateCommand } from "./commands/postgres-batch-update.command.js";
-import { create as createCommand } from "./commands/postgres-create.command.js";
-import { createMany as createManyCommand } from "./commands/postgres-create-many.command.js";
-import { deleteById as deleteByIdCommand } from "./commands/postgres-delete-by-id.command.js";
-import { deleteMany as deleteManyCommand } from "./commands/postgres-delete-many.command.js";
-import { fullUpdateById as fullUpdateByIdCommand } from "./commands/postgres-full-update-by-id.command.js";
-import { partialUpdateById as partialUpdateByIdCommand } from "./commands/postgres-partial-update-by-id.command.js";
-import { update as updateCommand } from "./commands/postgres-update.command.js";
-import { find as findQuery } from "./queries/postgres-find.query.js";
-import { findOne as findOneQuery } from "./queries/postgres-find-one.query.js";
-import { get as getQuery } from "./queries/postgres-get.query.js";
-import { getAll as getAllQuery } from "./queries/postgres-get-all.query.js";
-import { getById as getByIdQuery } from "./queries/postgres-get-by-id.query.js";
-import { getCount as getCountQuery } from "./queries/postgres-get-count.query.js";
-import { convertKeysToCamelCase, convertKeysToSnakeCase, toPostgresStoreName, } from "./utils/convert-keys.util.js";
-import { convertNullToUndefined } from "./utils/convert-null-to-undefined.util.js";
+import { batchUpdate as batchUpdateCommand } from './commands/postgres-batch-update.command.js';
+import { create as createCommand } from './commands/postgres-create.command.js';
+import { createMany as createManyCommand } from './commands/postgres-create-many.command.js';
+import { deleteById as deleteByIdCommand } from './commands/postgres-delete-by-id.command.js';
+import { deleteMany as deleteManyCommand } from './commands/postgres-delete-many.command.js';
+import { fullUpdateById as fullUpdateByIdCommand } from './commands/postgres-full-update-by-id.command.js';
+import { partialUpdateById as partialUpdateByIdCommand } from './commands/postgres-partial-update-by-id.command.js';
+import { update as updateCommand } from './commands/postgres-update.command.js';
+import { find as findQuery } from './queries/postgres-find.query.js';
+import { findOne as findOneQuery } from './queries/postgres-find-one.query.js';
+import { get as getQuery } from './queries/postgres-get.query.js';
+import { getAll as getAllQuery } from './queries/postgres-get-all.query.js';
+import { getById as getByIdQuery } from './queries/postgres-get-by-id.query.js';
+import { getCount as getCountQuery } from './queries/postgres-get-count.query.js';
+import { convertKeysToCamelCase, convertKeysToSnakeCase, toPostgresStoreName, } from './utils/convert-keys.util.js';
+import { convertNullToUndefined } from './utils/convert-null-to-undefined.util.js';
 export class PostgresDatabase {
     connection;
     constructor(connection) {
@@ -21,10 +21,10 @@ export class PostgresDatabase {
     }
     async close() {
         const connection = this.connection;
-        if (typeof connection.release === "function") {
+        if (typeof connection.release === 'function') {
             return;
         }
-        if (typeof connection.end === "function") {
+        if (typeof connection.end === 'function') {
             await connection.end();
         }
     }

package/dist/databases/postgres/queries/postgres-find-one.query.d.ts

@@ -1,3 +1,3 @@
 import type { PostgresConnection } from '../postgres-connection.js';
-import { IQueryOptions } from "@loomcore/common/models";
+import { IQueryOptions } from '@loomcore/common/models';
 export declare function findOne<T>(client: PostgresConnection, queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;

package/dist/databases/postgres/queries/postgres-find-one.query.js

@@ -1,5 +1,5 @@
-import { buildWhereClause } from "../utils/build-where-clause.js";
-import { buildOrderByClause } from "../utils/build-order-by-clause.js";
+import { buildWhereClause } from '../utils/build-where-clause.js';
+import { buildOrderByClause } from '../utils/build-order-by-clause.js';
 export async function findOne(client, queryObject, pluralResourceName) {
     const { whereClause, values } = buildWhereClause(queryObject);
     const orderByClause = buildOrderByClause(queryObject);

package/dist/databases/postgres/queries/postgres-find.query.d.ts

@@ -1,3 +1,3 @@
 import type { PostgresConnection } from '../postgres-connection.js';
-import { IQueryOptions } from "@loomcore/common/models";
+import { IQueryOptions } from '@loomcore/common/models';
 export declare function find<T>(client: PostgresConnection, queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/queries/postgres-find.query.js

@@ -1,5 +1,5 @@
-import { buildWhereClause } from "../utils/build-where-clause.js";
-import { buildOrderByClause } from "../utils/build-order-by-clause.js";
+import { buildWhereClause } from '../utils/build-where-clause.js';
+import { buildOrderByClause } from '../utils/build-order-by-clause.js';
 import { buildPaginationClause } from '../utils/build-pagination-clause.js';
 export async function find(client, queryObject, pluralResourceName) {
     const { whereClause, values } = buildWhereClause(queryObject);

package/dist/databases/postgres/queries/postgres-get-all.query.d.ts

@@ -1,3 +1,3 @@
 import type { PostgresConnection } from '../postgres-connection.js';
-import { Operation } from "../../operations/operation.js";
+import { Operation } from '../../operations/operation.js';
 export declare function getAll<T>(client: PostgresConnection, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/queries/postgres-get-all.query.js

@@ -1,6 +1,6 @@
-import { LeftJoin } from "../../operations/left-join.operation.js";
-import { InnerJoin } from "../../operations/inner-join.operation.js";
-import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
+import { LeftJoin } from '../../operations/left-join.operation.js';
+import { InnerJoin } from '../../operations/inner-join.operation.js';
+import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { buildSelectClause } from '../utils/build-select-clause.js';
 export async function getAll(client, operations, pluralResourceName) {

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

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

package/dist/databases/postgres/queries/postgres-get-by-id.query.js

@@ -1,8 +1,8 @@
-import { LeftJoin } from "../../operations/left-join.operation.js";
-import { InnerJoin } from "../../operations/inner-join.operation.js";
-import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
-import { buildJoinClauses } from "../utils/build-join-clauses.js";
-import { buildSelectClause } from "../utils/build-select-clause.js";
+import { LeftJoin } from '../../operations/left-join.operation.js';
+import { InnerJoin } from '../../operations/inner-join.operation.js';
+import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
+import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { buildSelectClause } from '../utils/build-select-clause.js';
 import { BadRequestError } from '../../../errors/index.js';
 import { buildWhereClause } from '../utils/build-where-clause.js';
 export async function getById(client, operations, queryObject, id, pluralResourceName) {

package/dist/databases/postgres/queries/postgres-get-count.query.js

@@ -1,4 +1,4 @@
-import { executeCountQuery } from "../utils/build-count-query.js";
+import { executeCountQuery } from '../utils/build-count-query.js';
 export async function getCount(client, pluralResourceName) {
     return executeCountQuery(client, pluralResourceName);
 }

package/dist/databases/postgres/queries/postgres-get.query.d.ts

@@ -1,4 +1,4 @@
 import type { PostgresConnection } from '../postgres-connection.js';
-import { IQueryOptions, IPagedResult } from "@loomcore/common/models";
-import { Operation } from "../../operations/operation.js";
+import { IQueryOptions, IPagedResult } from '@loomcore/common/models';
+import { Operation } from '../../operations/operation.js';
 export declare function get<T>(client: PostgresConnection, operations: Operation[], queryOptions: IQueryOptions, pluralResourceName: string): Promise<IPagedResult<T>>;

package/dist/databases/postgres/queries/postgres-get.query.js

@@ -1,12 +1,12 @@
-import { LeftJoin } from "../../operations/left-join.operation.js";
-import { InnerJoin } from "../../operations/inner-join.operation.js";
-import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
-import { buildWhereClause } from "../utils/build-where-clause.js";
-import { buildOrderByClause } from "../utils/build-order-by-clause.js";
-import { buildJoinClauses } from "../utils/build-join-clauses.js";
-import { buildSelectClause } from "../utils/build-select-clause.js";
-import { executeCountQuery } from "../utils/build-count-query.js";
-import { apiUtils } from "../../../utils/api.utils.js";
+import { LeftJoin } from '../../operations/left-join.operation.js';
+import { InnerJoin } from '../../operations/inner-join.operation.js';
+import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
+import { buildWhereClause } from '../utils/build-where-clause.js';
+import { buildOrderByClause } from '../utils/build-order-by-clause.js';
+import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { buildSelectClause } from '../utils/build-select-clause.js';
+import { executeCountQuery } from '../utils/build-count-query.js';
+import { apiUtils } from '../../../utils/api.utils.js';
 import { buildPaginationClause } from '../utils/build-pagination-clause.js';
 export async function get(client, operations, queryOptions, pluralResourceName) {
     const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);

package/dist/databases/postgres/utils/build-count-query.d.ts

@@ -1,3 +1,3 @@
 import type { PostgresConnection } from '../postgres-connection.js';
-import { IQueryOptions } from "@loomcore/common/models";
+import { IQueryOptions } from '@loomcore/common/models';
 export declare function executeCountQuery(client: PostgresConnection, pluralResourceName: string, queryOptions?: IQueryOptions): Promise<number>;

package/dist/databases/postgres/utils/build-count-query.js

@@ -1,4 +1,4 @@
-import { buildWhereClause } from "./build-where-clause.js";
+import { buildWhereClause } from './build-where-clause.js';
 export async function executeCountQuery(client, pluralResourceName, queryOptions = {}) {
     const { whereClause, values } = buildWhereClause(queryOptions);
     const countQuery = `SELECT COUNT(*) as total FROM "${pluralResourceName}" ${whereClause}`;

package/dist/databases/postgres/utils/build-join-clauses.d.ts

@@ -1,4 +1,4 @@
-import { Operation } from "../../operations/operation.js";
+import { Operation } from '../../operations/operation.js';
 export interface BuildJoinClausesOptions {
     oneToOneOnly?: boolean;
 }

package/dist/databases/postgres/utils/build-join-clauses.js

@@ -1,7 +1,7 @@
-import { LeftJoin } from "../../operations/left-join.operation.js";
-import { InnerJoin } from "../../operations/inner-join.operation.js";
-import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
-import { toPostgresStoreName } from "./convert-keys.util.js";
+import { LeftJoin } from '../../operations/left-join.operation.js';
+import { InnerJoin } from '../../operations/inner-join.operation.js';
+import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
+import { toPostgresStoreName } from './convert-keys.util.js';
 function getParentAlias(localField) {
     if (!localField.includes('.'))
         return null;
@@ -37,10 +37,10 @@ export function buildJoinClauses(operations, mainTableName, options) {
         }
         if (operation instanceof LeftJoin || operation instanceof InnerJoin || operation instanceof LeftJoinMany) {
             const useLeftJoin = oneToOneOnly && operation instanceof InnerJoin && throughTableAliases.has(operation.as);
-            const joinType = useLeftJoin || operation instanceof LeftJoin || operation instanceof LeftJoinMany ? "LEFT JOIN" : "INNER JOIN";
+            const joinType = useLeftJoin || operation instanceof LeftJoin || operation instanceof LeftJoinMany ? 'LEFT JOIN' : 'INNER JOIN';
             let leftSide;
-            if (operation.localField.includes(".")) {
-                const [alias, column] = operation.localField.split(".");
+            if (operation.localField.includes('.')) {
+                const [alias, column] = operation.localField.split('.');
                 leftSide = `"${alias}"."${column}"`;
             }
             else {

package/dist/databases/postgres/utils/build-order-by-clause.d.ts

@@ -1,4 +1,4 @@
-import { IQueryOptions } from "@loomcore/common/models";
+import { IQueryOptions } from '@loomcore/common/models';
 export interface BuildOrderByClauseOptions {
     tablePrefix?: string;
 }

package/dist/databases/postgres/utils/build-pagination-clause.d.ts

@@ -1,2 +1,2 @@
-import { IQueryOptions } from "@loomcore/common/models";
+import { IQueryOptions } from '@loomcore/common/models';
 export declare function buildPaginationClause(queryObject: IQueryOptions): string;

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

@@ -1,4 +1,4 @@
-import { IDatabaseConfig } from "../../../models/database-config.interface.js";
+import { IDatabaseConfig } from '../../../models/database-config.interface.js';
 export declare function buildPostgresUrl(config: {
     database: IDatabaseConfig;
 }): string;

package/dist/databases/postgres/utils/build-postgres-url.util.js

@@ -1,11 +1,11 @@
 export function buildPostgresUrl(config) {
     const { database } = config;
     if (!database) {
-        throw new Error("Database configuration is required to build the PostgreSQL URL.");
+        throw new Error('Database configuration is required to build the PostgreSQL URL.');
     }
     const { username, password, host, port, name } = database;
     if (!username || !password || !host || !port || !name) {
-        throw new Error("Database configuration must include user, password, host, port, and name to build the PostgreSQL URL.");
+        throw new Error('Database configuration must include user, password, host, port, and name to build the PostgreSQL URL.');
     }
     const encodedUsername = encodeURIComponent(username);
     const encodedPassword = encodeURIComponent(password);