@loomcore/api 0.1.92 → 0.1.94

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

@@ -70,23 +70,23 @@ export class PostgresDatabase {
     }
     async getUserAuthorizations(userId, orgId) {
         const now = new Date();
-        let query = `
-            SELECT DISTINCT
-                ur."user_id" as "userId",
-                r."name" as "role",
-                f."name" as "feature",
-                a."config",
-                a."_id",
-                a."_orgId"
-            FROM "user_roles" ur
-            INNER JOIN "roles" r ON ur."role_id" = r."_id"
-            INNER JOIN "authorizations" a ON r."_id" = a."role_id"
-            INNER JOIN "features" f ON a."feature_id" = f."_id"
-            WHERE ur."user_id" = $1
-                AND ur."_deleted" IS NULL
-                AND a."_deleted" IS NULL
-                AND (a."start_date" IS NULL OR a."start_date" <= $2)
-                AND (a."end_date" IS NULL OR a."end_date" >= $2)
+        let query = `
+            SELECT DISTINCT
+                ur."user_id" as "userId",
+                r."name" as "role",
+                f."name" as "feature",
+                a."config",
+                a."_id",
+                a."_orgId"
+            FROM "user_roles" ur
+            INNER JOIN "roles" r ON ur."role_id" = r."_id"
+            INNER JOIN "authorizations" a ON r."_id" = a."role_id"
+            INNER JOIN "features" f ON a."feature_id" = f."_id"
+            WHERE ur."user_id" = $1
+                AND ur."_deleted" IS NULL
+                AND a."_deleted" IS NULL
+                AND (a."start_date" IS NULL OR a."start_date" <= $2)
+                AND (a."end_date" IS NULL OR a."end_date" >= $2)
         `;
         const values = [userId, now];
         if (orgId) {

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

@@ -116,53 +116,53 @@ export function buildJoinClauses(operations, mainTableName) {
                         });
                         if (nestedJoin) {
                             const nestedField = nestedJoin.localField.split('.')[1];
-                            enrichmentJoins += ` LEFT JOIN LATERAL (
-                                SELECT COALESCE(
-                                    JSON_AGG(
-                                        enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
-                                    ),
-                                    '[]'::json
-                                ) AS enriched
-                                FROM (
-                                    SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                    FROM "${enrichOp.from}" AS enrich_table
-                                    WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                    AND enrich_table."_deleted" IS NULL
-                                ) AS enrich_data
-                                CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
-                                LEFT JOIN LATERAL (
-                                    SELECT row_to_json(nested_table) AS ${nestedJoin.as}
-                                    FROM "${nestedJoin.from}" AS nested_table
-                                    WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
-                                    AND nested_table."_deleted" IS NULL
-                                    LIMIT 1
-                                ) AS nested_join_data ON true
+                            enrichmentJoins += ` LEFT JOIN LATERAL (
+                                SELECT COALESCE(
+                                    JSON_AGG(
+                                        enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
+                                    ),
+                                    '[]'::json
+                                ) AS enriched
+                                FROM (
+                                    SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
+                                    FROM "${enrichOp.from}" AS enrich_table
+                                    WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
+                                    AND enrich_table."_deleted" IS NULL
+                                ) AS enrich_data
+                                CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
+                                LEFT JOIN LATERAL (
+                                    SELECT row_to_json(nested_table) AS ${nestedJoin.as}
+                                    FROM "${nestedJoin.from}" AS nested_table
+                                    WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
+                                    AND nested_table."_deleted" IS NULL
+                                    LIMIT 1
+                                ) AS nested_join_data ON true
                             ) AS ${enrichAlias} ON true`;
                         }
                         else {
-                            enrichmentJoins += ` LEFT JOIN LATERAL (
-                                SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                FROM "${enrichOp.from}" AS enrich_table
-                                WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                AND enrich_table."_deleted" IS NULL
+                            enrichmentJoins += ` LEFT JOIN LATERAL (
+                                SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
+                                FROM "${enrichOp.from}" AS enrich_table
+                                WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
+                                AND enrich_table."_deleted" IS NULL
                             ) AS ${enrichAlias} ON true`;
                         }
                         jsonBuildObjects += ` || jsonb_build_object('${enrichOp.as}', COALESCE(${enrichAlias}.enriched, '[]'::json))`;
                     }
-                    joinClauses += ` LEFT JOIN LATERAL (
-                        SELECT COALESCE(
-                            JSON_AGG(
-                                elem.value${jsonBuildObjects}
-                            ),
-                            '[]'::json
-                        ) AS aggregated
-                        FROM (
-                            SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
-                            FROM "${target.from}" AS target_table
-                            WHERE target_table."${target.foreignField}" = ${targetLocalFieldRef}
-                            AND target_table."_deleted" IS NULL
-                        ) AS original_data
-                        CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
+                    joinClauses += ` LEFT JOIN LATERAL (
+                        SELECT COALESCE(
+                            JSON_AGG(
+                                elem.value${jsonBuildObjects}
+                            ),
+                            '[]'::json
+                        ) AS aggregated
+                        FROM (
+                            SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
+                            FROM "${target.from}" AS target_table
+                            WHERE target_table."${target.foreignField}" = ${targetLocalFieldRef}
+                            AND target_table."_deleted" IS NULL
+                        ) AS original_data
+                        CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
                     ) AS ${target.as} ON true`;
                     enrichedAliases.add(target.as);
                     processedAliases.add(target.as);
@@ -173,26 +173,26 @@ export function buildJoinClauses(operations, mainTableName) {
             }
             else {
                 const localFieldRef = resolveLocalField(operation.localField, mainTableName, operations);
-                joinClauses += ` LEFT JOIN LATERAL (
-                    SELECT COALESCE(JSON_AGG(row_to_json("${operation.from}")), '[]'::json) AS aggregated
-                    FROM "${operation.from}"
-                    WHERE "${operation.from}"."${operation.foreignField}" = ${localFieldRef}
-                    AND "${operation.from}"."_deleted" IS NULL
+                joinClauses += ` LEFT JOIN LATERAL (
+                    SELECT COALESCE(JSON_AGG(row_to_json("${operation.from}")), '[]'::json) AS aggregated
+                    FROM "${operation.from}"
+                    WHERE "${operation.from}"."${operation.foreignField}" = ${localFieldRef}
+                    AND "${operation.from}"."_deleted" IS NULL
                 ) AS ${operation.as} ON true`;
                 processedAliases.add(operation.as);
             }
         }
         else if (operation instanceof JoinThrough) {
             const localFieldRef = resolveLocalField(operation.localField, mainTableName, operations);
-            joinClauses += ` LEFT JOIN LATERAL (
-                SELECT row_to_json(${operation.as}) AS aggregated
-                FROM "${operation.through}"
-                INNER JOIN "${operation.from}" AS ${operation.as} 
-                    ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
-                WHERE "${operation.through}"."${operation.throughLocalField}" = ${localFieldRef}
-                AND "${operation.through}"."_deleted" IS NULL
-                AND ${operation.as}."_deleted" IS NULL
-                LIMIT 1
+            joinClauses += ` LEFT JOIN LATERAL (
+                SELECT row_to_json(${operation.as}) AS aggregated
+                FROM "${operation.through}"
+                INNER JOIN "${operation.from}" AS ${operation.as} 
+                    ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
+                WHERE "${operation.through}"."${operation.throughLocalField}" = ${localFieldRef}
+                AND "${operation.through}"."_deleted" IS NULL
+                AND ${operation.as}."_deleted" IS NULL
+                LIMIT 1
             ) AS ${operation.as} ON true`;
             processedAliases.add(operation.as);
         }
@@ -221,35 +221,35 @@ export function buildJoinClauses(operations, mainTableName) {
                                 j.localField.startsWith(`${enrichOp.as}.`));
                             if (nestedJoin) {
                                 const nestedField = nestedJoin.localField.split('.')[1];
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(
-                                        JSON_AGG(
-                                            enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
-                                        ),
-                                        '[]'::json
-                                    ) AS enriched
-                                    FROM (
-                                        SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                        FROM "${enrichOp.from}" AS enrich_table
-                                        WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                        AND enrich_table."_deleted" IS NULL
-                                    ) AS enrich_data
-                                    CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
-                                    LEFT JOIN LATERAL (
-                                        SELECT row_to_json(nested_table) AS ${nestedJoin.as}
-                                        FROM "${nestedJoin.from}" AS nested_table
-                                        WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
-                                        AND nested_table."_deleted" IS NULL
-                                        LIMIT 1
-                                    ) AS nested_join_data ON true
+                                enrichmentJoins += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(
+                                        JSON_AGG(
+                                            enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
+                                        ),
+                                        '[]'::json
+                                    ) AS enriched
+                                    FROM (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
+                                        FROM "${enrichOp.from}" AS enrich_table
+                                        WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
+                                        AND enrich_table."_deleted" IS NULL
+                                    ) AS enrich_data
+                                    CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
+                                    LEFT JOIN LATERAL (
+                                        SELECT row_to_json(nested_table) AS ${nestedJoin.as}
+                                        FROM "${nestedJoin.from}" AS nested_table
+                                        WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
+                                        AND nested_table."_deleted" IS NULL
+                                        LIMIT 1
+                                    ) AS nested_join_data ON true
                                 ) AS ${enrichAlias} ON true`;
                             }
                             else {
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                    FROM "${enrichOp.from}" AS enrich_table
-                                    WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                    AND enrich_table."_deleted" IS NULL
+                                enrichmentJoins += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
+                                    FROM "${enrichOp.from}" AS enrich_table
+                                    WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
+                                    AND enrich_table."_deleted" IS NULL
                                 ) AS ${enrichAlias} ON true`;
                             }
                         }
@@ -270,82 +270,82 @@ export function buildJoinClauses(operations, mainTableName) {
                             });
                             if (nestedJoin) {
                                 const nestedField = nestedJoin.localField.split('.')[1];
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(
-                                        JSON_AGG(
-                                            enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
-                                        ),
-                                        '[]'::json
-                                    ) AS enriched
-                                    FROM (
-                                        SELECT COALESCE(JSON_AGG(row_to_json(${enrichAlias}_table)), '[]'::json) AS enriched
-                                        FROM "${enrichOp.through}"
-                                        INNER JOIN "${enrichOp.from}" AS ${enrichAlias}_table 
-                                            ON ${enrichAlias}_table."${enrichOp.foreignField}" = "${enrichOp.through}"."${enrichOp.throughForeignField}"
-                                        WHERE "${enrichOp.through}"."${enrichOp.throughLocalField}" = (elem.value->>'${enrichField}')::integer
-                                        AND "${enrichOp.through}"."_deleted" IS NULL
-                                        AND ${enrichAlias}_table."_deleted" IS NULL
-                                    ) AS enrich_data
-                                    CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
-                                    LEFT JOIN LATERAL (
-                                        SELECT row_to_json(nested_table) AS ${nestedJoin.as}
-                                        FROM "${nestedJoin.from}" AS nested_table
-                                        WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
-                                        AND nested_table."_deleted" IS NULL
-                                        LIMIT 1
-                                    ) AS nested_join_data ON true
+                                enrichmentJoins += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(
+                                        JSON_AGG(
+                                            enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
+                                        ),
+                                        '[]'::json
+                                    ) AS enriched
+                                    FROM (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(${enrichAlias}_table)), '[]'::json) AS enriched
+                                        FROM "${enrichOp.through}"
+                                        INNER JOIN "${enrichOp.from}" AS ${enrichAlias}_table 
+                                            ON ${enrichAlias}_table."${enrichOp.foreignField}" = "${enrichOp.through}"."${enrichOp.throughForeignField}"
+                                        WHERE "${enrichOp.through}"."${enrichOp.throughLocalField}" = (elem.value->>'${enrichField}')::integer
+                                        AND "${enrichOp.through}"."_deleted" IS NULL
+                                        AND ${enrichAlias}_table."_deleted" IS NULL
+                                    ) AS enrich_data
+                                    CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
+                                    LEFT JOIN LATERAL (
+                                        SELECT row_to_json(nested_table) AS ${nestedJoin.as}
+                                        FROM "${nestedJoin.from}" AS nested_table
+                                        WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
+                                        AND nested_table."_deleted" IS NULL
+                                        LIMIT 1
+                                    ) AS nested_join_data ON true
                                 ) AS ${enrichAlias} ON true`;
                             }
                             else {
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(JSON_AGG(row_to_json(${enrichAlias}_table)), '[]'::json) AS enriched
-                                    FROM "${enrichOp.through}"
-                                    INNER JOIN "${enrichOp.from}" AS ${enrichAlias}_table 
-                                        ON ${enrichAlias}_table."${enrichOp.foreignField}" = "${enrichOp.through}"."${enrichOp.throughForeignField}"
-                                    WHERE "${enrichOp.through}"."${enrichOp.throughLocalField}" = (elem.value->>'${enrichField}')::integer
-                                    AND "${enrichOp.through}"."_deleted" IS NULL
-                                    AND ${enrichAlias}_table."_deleted" IS NULL
+                                enrichmentJoins += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(JSON_AGG(row_to_json(${enrichAlias}_table)), '[]'::json) AS enriched
+                                    FROM "${enrichOp.through}"
+                                    INNER JOIN "${enrichOp.from}" AS ${enrichAlias}_table 
+                                        ON ${enrichAlias}_table."${enrichOp.foreignField}" = "${enrichOp.through}"."${enrichOp.throughForeignField}"
+                                    WHERE "${enrichOp.through}"."${enrichOp.throughLocalField}" = (elem.value->>'${enrichField}')::integer
+                                    AND "${enrichOp.through}"."_deleted" IS NULL
+                                    AND ${enrichAlias}_table."_deleted" IS NULL
                                 ) AS ${enrichAlias} ON true`;
                             }
                         }
                         jsonBuildObjects += ` || jsonb_build_object('${enrichOp.as}', COALESCE(${enrichAlias}.enriched, '[]'::json))`;
                     }
                     if (isTargetJoinMany) {
-                        joinClauses += ` LEFT JOIN LATERAL (
-                            SELECT COALESCE(
-                                JSON_AGG(
-                                    elem.value${jsonBuildObjects}
-                                ),
-                                '[]'::json
-                            ) AS aggregated
-                            FROM (
-                                SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
-                                FROM "${target.from}" AS target_table
-                                WHERE target_table."${target.foreignField}" = ${targetLocalFieldRef}
-                                AND target_table."_deleted" IS NULL
-                            ) AS original_data
-                            CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
+                        joinClauses += ` LEFT JOIN LATERAL (
+                            SELECT COALESCE(
+                                JSON_AGG(
+                                    elem.value${jsonBuildObjects}
+                                ),
+                                '[]'::json
+                            ) AS aggregated
+                            FROM (
+                                SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
+                                FROM "${target.from}" AS target_table
+                                WHERE target_table."${target.foreignField}" = ${targetLocalFieldRef}
+                                AND target_table."_deleted" IS NULL
+                            ) AS original_data
+                            CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
                         ) AS ${target.as} ON true`;
                     }
                     else {
                         const targetThrough = target;
-                        joinClauses += ` LEFT JOIN LATERAL (
-                            SELECT COALESCE(
-                                JSON_AGG(
-                                    elem.value${jsonBuildObjects}
-                                ),
-                                '[]'::json
-                            ) AS aggregated
-                            FROM (
-                                SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
-                                FROM "${targetThrough.through}"
-                                INNER JOIN "${targetThrough.from}" AS target_table 
-                                    ON target_table."${targetThrough.foreignField}" = "${targetThrough.through}"."${targetThrough.throughForeignField}"
-                                WHERE "${targetThrough.through}"."${targetThrough.throughLocalField}" = ${targetLocalFieldRef}
-                                AND "${targetThrough.through}"."_deleted" IS NULL
-                                AND target_table."_deleted" IS NULL
-                            ) AS original_data
-                            CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
+                        joinClauses += ` LEFT JOIN LATERAL (
+                            SELECT COALESCE(
+                                JSON_AGG(
+                                    elem.value${jsonBuildObjects}
+                                ),
+                                '[]'::json
+                            ) AS aggregated
+                            FROM (
+                                SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
+                                FROM "${targetThrough.through}"
+                                INNER JOIN "${targetThrough.from}" AS target_table 
+                                    ON target_table."${targetThrough.foreignField}" = "${targetThrough.through}"."${targetThrough.throughForeignField}"
+                                WHERE "${targetThrough.through}"."${targetThrough.throughLocalField}" = ${targetLocalFieldRef}
+                                AND "${targetThrough.through}"."_deleted" IS NULL
+                                AND target_table."_deleted" IS NULL
+                            ) AS original_data
+                            CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
                         ) AS ${target.as} ON true`;
                     }
                     enrichedAliases.add(target.as);
@@ -357,14 +357,14 @@ export function buildJoinClauses(operations, mainTableName) {
             }
             else {
                 const localFieldRef = resolveLocalField(operation.localField, mainTableName, operations);
-                joinClauses += ` LEFT JOIN LATERAL (
-                    SELECT COALESCE(JSON_AGG(row_to_json(${operation.as})), '[]'::json) AS aggregated
-                    FROM "${operation.through}"
-                    INNER JOIN "${operation.from}" AS ${operation.as} 
-                        ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
-                    WHERE "${operation.through}"."${operation.throughLocalField}" = ${localFieldRef}
-                    AND "${operation.through}"."_deleted" IS NULL
-                    AND ${operation.as}."_deleted" IS NULL
+                joinClauses += ` LEFT JOIN LATERAL (
+                    SELECT COALESCE(JSON_AGG(row_to_json(${operation.as})), '[]'::json) AS aggregated
+                    FROM "${operation.through}"
+                    INNER JOIN "${operation.from}" AS ${operation.as} 
+                        ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
+                    WHERE "${operation.through}"."${operation.throughLocalField}" = ${localFieldRef}
+                    AND "${operation.through}"."_deleted" IS NULL
+                    AND ${operation.as}."_deleted" IS NULL
                 ) AS ${operation.as} ON true`;
                 processedAliases.add(operation.as);
             }

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

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

package/dist/databases/postgres/utils/build-select-clause.js

@@ -3,12 +3,12 @@ import { JoinMany } from '../../operations/join-many.operation.js';
 import { JoinThrough } from '../../operations/join-through.operation.js';
 import { JoinThroughMany } from '../../operations/join-through-many.operation.js';
 async function getTableColumns(client, tableName) {
-    const result = await client.query(`
-            SELECT column_name
-            FROM information_schema.columns
-            WHERE table_schema = current_schema()
-              AND table_name = $1
-            ORDER BY ordinal_position
+    const result = await client.query(`
+            SELECT column_name
+            FROM information_schema.columns
+            WHERE table_schema = current_schema()
+              AND table_name = $1
+            ORDER BY ordinal_position
         `, [tableName]);
     return result.rows.map(row => row.column_name);
 }

package/dist/databases/postgres/utils/does-table-exist.util.js

@@ -1,8 +1,8 @@
 export async function doesTableExist(client, tableName) {
-    const result = await client.query(`
-        SELECT EXISTS (
-            SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1
-        )
+    const result = await client.query(`
+        SELECT EXISTS (
+            SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1
+        )
     `, [tableName]);
     return result.rows[0].exists;
 }

package/dist/models/app-config.interface.d.ts

@@ -0,0 +1,8 @@
+import { DbType } from "../databases/db-type.type.js";
+export interface IAppConfig {
+    dbType: DbType;
+    isMultiTenant: boolean;
+    isAuthEnabled: boolean;
+    name: string;
+    primaryTimezone?: string;
+}

package/dist/models/base-api-config.interface.d.ts

@@ -1,30 +1,17 @@
-import { DbType } from "../databases/db-type.type.js";
+import { IAppConfig } from "./app-config.interface.js";
 import { IAuthConfig } from "./auth-config.interface.js";
+import { IDatabaseConfig } from "./database-config.interface.js";
 import { IEmailConfig } from "./email-config.interface.js";
 import { IEmailClient } from "./email-client.interface.js";
-import { IMultiTenantConfig } from "./multi-tenant-config.interface.js";
 export interface IBaseApiConfig {
-    app: {
-        dbType: DbType;
-        isMultiTenant: boolean;
-        isAuthEnabled: boolean;
-        name: string;
-        primaryTimezone?: string;
-    };
+    app: IAppConfig;
     auth?: IAuthConfig;
-    database: {
-        host: string;
-        name: string;
-        password: string;
-        port: number;
-        username: string;
-    };
+    database: IDatabaseConfig;
     debug?: {
         showErrors?: boolean;
     };
     email?: IEmailConfig;
     env: string;
-    multiTenant?: IMultiTenantConfig;
     network: {
         corsAllowedOrigins: string[];
         externalPort?: number;

package/dist/models/database-config.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IDatabaseConfig {
+    host: string;
+    name: string;
+    password: string;
+    port: number;
+    username: string;
+}

package/dist/models/index.d.ts

@@ -1,4 +1,6 @@
+export * from './app-config.interface.js';
 export * from './base-api-config.interface.js';
-export * from './reset-api-config.interface.js';
+export * from './database-config.interface.js';
+export * from './initial-database-config.interface.js';
 export * from './refresh-token.model.js';
 export * from './email-client.interface.js';

package/dist/models/index.js

@@ -1,4 +1,6 @@
+export * from './app-config.interface.js';
 export * from './base-api-config.interface.js';
-export * from './reset-api-config.interface.js';
+export * from './database-config.interface.js';
+export * from './initial-database-config.interface.js';
 export * from './refresh-token.model.js';
 export * from './email-client.interface.js';

package/dist/models/initial-database-config.interface.d.ts

@@ -0,0 +1,16 @@
+import { IAppConfig } from "./app-config.interface.js";
+import { IDatabaseConfig } from "./database-config.interface.js";
+import { IEmailConfig } from "./email-config.interface.js";
+export interface IInitialDbMigrationConfig {
+    app: IAppConfig;
+    database: IDatabaseConfig;
+    adminUser: {
+        email: string;
+        password: string;
+    };
+    multiTenant: {
+        metaOrgName: string;
+        metaOrgCode: string;
+    };
+    email?: IEmailConfig;
+}

package/dist/models/initial-database-config.interface.js

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