@loomcore/api 0.0.59 → 0.1.2

package/dist/databases/postgres/migrations/setup-for-multitenant.migration.js

@@ -0,0 +1,16 @@
+import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
+import { CreateOrganizationTableMigration } from "./002-create-organizations-table.migration.js";
+export async function setupDatabaseForMultitenant(client, orgId) {
+    const migrations = [
+        new CreateMigrationTableMigration(client, orgId),
+        new CreateOrganizationTableMigration(client, orgId),
+    ];
+    let success = true;
+    for (const migration of migrations) {
+        success = await migration.execute();
+        if (!success) {
+            return false;
+        }
+    }
+    return success;
+}

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

@@ -0,0 +1,31 @@
+import { IQueryOptions, IModelSpec, IPagedResult, IEntity } from "@loomcore/common/models";
+import { TSchema } from "@sinclair/typebox";
+import { DeleteResult, IDatabase } from "../models/index.js";
+import { Operation } from "../operations/operation.js";
+import { Client } from 'pg';
+export declare class PostgresDatabase implements IDatabase {
+    private client;
+    constructor(client: Client);
+    preprocessEntity<T extends IEntity>(entity: Partial<T>, modelSpec: TSchema): Partial<T>;
+    postprocessEntity<T extends IEntity>(entity: T, modelSpec: TSchema): T;
+    getAll<T extends IEntity>(operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    get<T extends IEntity>(operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;
+    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+    getCount(pluralResourceName: string): Promise<number>;
+    create<T extends IEntity>(entity: Partial<T>, pluralResourceName: string): Promise<{
+        insertedId: string;
+        entity: T;
+    }>;
+    createMany<T extends IEntity>(entities: Partial<T>[], pluralResourceName: string): Promise<{
+        insertedIds: string[];
+        entities: T[];
+    }>;
+    batchUpdate<T extends IEntity>(entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    fullUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    partialUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    update<T extends IEntity>(queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    deleteById(id: string, pluralResourceName: string): Promise<DeleteResult>;
+    deleteMany(queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;
+    find<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    findOne<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;
+}

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

@@ -0,0 +1,69 @@
+import { create as createCommand } from "./commands/postgres-create.command.js";
+import { createMany as createManyCommand } from "./commands/postgres-create-many.command.js";
+import { batchUpdate as batchUpdateCommand } from "./commands/postgres-batch-update.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 { deleteById as deleteByIdCommand } from "./commands/postgres-delete-by-id.command.js";
+import { deleteMany as deleteManyCommand } from "./commands/postgres-delete-many.command.js";
+import { findOne as findOneQuery } from "./queries/postgres-find-one.query.js";
+import { find as findQuery } from "./queries/postgres-find.query.js";
+import { getAll as getAllQuery } from "./queries/postgres-get-all.query.js";
+import { get as getQuery } from "./queries/postgres-get.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 { convertNullToUndefined } from "./utils/convert-null-to-undefined.util.js";
+export class PostgresDatabase {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    preprocessEntity(entity, modelSpec) {
+        return entity;
+    }
+    postprocessEntity(entity, modelSpec) {
+        return convertNullToUndefined(entity, modelSpec);
+    }
+    async getAll(operations, pluralResourceName) {
+        return getAllQuery(this.client, operations, pluralResourceName);
+    }
+    async get(operations, queryOptions, modelSpec, pluralResourceName) {
+        return getQuery(this.client, operations, queryOptions, pluralResourceName);
+    }
+    async getById(operations, queryObject, id, pluralResourceName) {
+        return getByIdQuery(this.client, operations, queryObject, id, pluralResourceName);
+    }
+    async getCount(pluralResourceName) {
+        return getCountQuery(this.client, pluralResourceName);
+    }
+    async create(entity, pluralResourceName) {
+        return createCommand(this.client, pluralResourceName, entity);
+    }
+    async createMany(entities, pluralResourceName) {
+        return createManyCommand(this.client, pluralResourceName, entities);
+    }
+    async batchUpdate(entities, operations, queryObject, pluralResourceName) {
+        return batchUpdateCommand(this.client, entities, operations, queryObject, pluralResourceName);
+    }
+    async fullUpdateById(operations, id, entity, pluralResourceName) {
+        return fullUpdateByIdCommand(this.client, operations, id, entity, pluralResourceName);
+    }
+    async partialUpdateById(operations, id, entity, pluralResourceName) {
+        return partialUpdateByIdCommand(this.client, operations, id, entity, pluralResourceName);
+    }
+    async update(queryObject, entity, operations, pluralResourceName) {
+        return updateCommand(this.client, queryObject, entity, operations, pluralResourceName);
+    }
+    async deleteById(id, pluralResourceName) {
+        return deleteByIdCommand(this.client, id, pluralResourceName);
+    }
+    async deleteMany(queryObject, pluralResourceName) {
+        return deleteManyCommand(this.client, queryObject, pluralResourceName);
+    }
+    async find(queryObject, pluralResourceName) {
+        return findQuery(this.client, queryObject, pluralResourceName);
+    }
+    async findOne(queryObject, pluralResourceName) {
+        return findOneQuery(this.client, queryObject, pluralResourceName);
+    }
+}

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

@@ -0,0 +1,3 @@
+import { Client } from 'pg';
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function findOne<T>(client: Client, queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;

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

@@ -0,0 +1,13 @@
+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);
+    const query = `SELECT * FROM "${pluralResourceName}" ${whereClause} ${orderByClause} LIMIT 1`;
+    const result = await client.query(query, values);
+    if (result.rows.length === 0) {
+        return null;
+    }
+    const row = result.rows[0];
+    return row;
+}

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

@@ -0,0 +1,3 @@
+import { Client } from 'pg';
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function find<T>(client: Client, queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;

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

@@ -0,0 +1,11 @@
+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);
+    const orderByClause = buildOrderByClause(queryObject);
+    const paginationClause = buildPaginationClause(queryObject);
+    const query = `SELECT * FROM "${pluralResourceName}" ${whereClause} ${orderByClause} ${paginationClause}`.trim();
+    const result = await client.query(query, values);
+    return result.rows;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { Join } from "../../operations/join.operation.js";
+import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { buildSelectClause } from '../utils/build-select-clause.js';
+import { transformJoinResults } from '../utils/transform-join-results.js';
+export async function getAll(client, operations, pluralResourceName) {
+    const joinClauses = buildJoinClauses(operations, pluralResourceName);
+    const hasJoins = operations.some(op => op instanceof Join);
+    const selectClause = hasJoins
+        ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+        : '*';
+    const query = `SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}`;
+    const result = await client.query(query);
+    return transformJoinResults(result.rows, operations);
+}

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

@@ -0,0 +1,4 @@
+import { Client } from 'pg';
+import { Operation } from "../../operations/operation.js";
+import { IQueryOptions } from '@loomcore/common/models';
+export declare function getById<T>(client: Client, operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;

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

@@ -0,0 +1,26 @@
+import { Join } from "../../operations/join.operation.js";
+import { buildJoinClauses } from "../utils/build-join-clauses.js";
+import { buildSelectClause } from "../utils/build-select-clause.js";
+import { transformJoinResults } from "../utils/transform-join-results.js";
+import { BadRequestError } from '../../../errors/index.js';
+import { buildWhereClause } from '../utils/build-where-clause.js';
+export async function getById(client, operations, queryObject, id, pluralResourceName) {
+    if (!id)
+        throw new BadRequestError('id is required');
+    const joinClauses = buildJoinClauses(operations, pluralResourceName);
+    const hasJoins = operations.some(op => op instanceof Join);
+    const selectClause = hasJoins
+        ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+        : '*';
+    queryObject.filters || (queryObject.filters = {});
+    queryObject.filters._id = { eq: id };
+    const tablePrefix = hasJoins ? pluralResourceName : undefined;
+    const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
+    const query = `SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses} ${whereClause} LIMIT 1`;
+    const result = await client.query(query, values);
+    if (result.rows.length === 0) {
+        return null;
+    }
+    const transformed = transformJoinResults([result.rows[0]], operations);
+    return transformed[0] || null;
+}

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

@@ -0,0 +1,2 @@
+import { Client } from 'pg';
+export declare function getCount(client: Client, pluralResourceName: string): Promise<number>;

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

@@ -0,0 +1,4 @@
+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

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

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

@@ -0,0 +1,26 @@
+import { Join } from "../../operations/join.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 { transformJoinResults } from "../utils/transform-join-results.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 joinClauses = buildJoinClauses(operations, pluralResourceName);
+    const orderByClause = buildOrderByClause(queryOptions);
+    const paginationClause = buildPaginationClause(queryOptions);
+    const hasJoins = operations.some(op => op instanceof Join);
+    const selectClause = hasJoins
+        ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+        : '*';
+    const tablePrefix = hasJoins ? pluralResourceName : undefined;
+    const { whereClause, values } = buildWhereClause(queryOptions, [], tablePrefix);
+    const baseQuery = `SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses} ${whereClause}`;
+    const total = await executeCountQuery(client, pluralResourceName, queryOptions);
+    const dataQuery = `${baseQuery} ${orderByClause} ${paginationClause}`.trim();
+    const dataResult = await client.query(dataQuery, values);
+    const entities = transformJoinResults(dataResult.rows, operations);
+    return apiUtils.getPagedResult(entities, total, queryOptions);
+}

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

@@ -0,0 +1,3 @@
+import { Client } from 'pg';
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function executeCountQuery(client: Client, pluralResourceName: string, queryOptions?: IQueryOptions): Promise<number>;

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

@@ -0,0 +1,7 @@
+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}`;
+    const countResult = await client.query(countQuery, values);
+    return parseInt(countResult.rows[0].total, 10);
+}

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

@@ -0,0 +1,2 @@
+import { Operation } from "../../operations/operation.js";
+export declare function buildJoinClauses(operations: Operation[], mainTableName?: string): string;

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

@@ -0,0 +1,12 @@
+import { Join } from "../../operations/join.operation.js";
+export function buildJoinClauses(operations, mainTableName) {
+    let joinClauses = '';
+    const joinOperations = operations.filter(op => op instanceof Join);
+    for (const operation of joinOperations) {
+        const localFieldRef = mainTableName
+            ? `"${mainTableName}"."${operation.localField}"`
+            : `"${operation.localField}"`;
+        joinClauses += ` LEFT JOIN "${operation.from}" AS ${operation.as} ON ${localFieldRef} = "${operation.as}"."${operation.foreignField}"`;
+    }
+    return joinClauses;
+}

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

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

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

@@ -0,0 +1,8 @@
+export function buildOrderByClause(queryObject) {
+    if (!queryObject.orderBy) {
+        return '';
+    }
+    const orderBy = queryObject.orderBy;
+    const sortDirection = queryObject.sortDirection || 'asc';
+    return `ORDER BY ${orderBy} ${sortDirection}`;
+}

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

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

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

@@ -0,0 +1,9 @@
+export function buildPaginationClause(queryObject) {
+    if (!queryObject.page || !queryObject.pageSize) {
+        return '';
+    }
+    const page = queryObject.page;
+    const pageSize = queryObject.pageSize;
+    const offset = (page - 1) * pageSize;
+    return `LIMIT ${pageSize} OFFSET ${offset}`;
+}

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

@@ -0,0 +1,3 @@
+import { Client } from 'pg';
+import { Operation } from '../../operations/operation.js';
+export declare function buildSelectClause(client: Client, mainTableName: string, mainTableAlias: string, operations: Operation[]): Promise<string>;

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

@@ -0,0 +1,28 @@
+import { Join } from '../../operations/join.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
+        `, [tableName]);
+    return result.rows.map(row => row.column_name);
+}
+export async function buildSelectClause(client, mainTableName, mainTableAlias, operations) {
+    const joinOperations = operations.filter(op => op instanceof Join);
+    const mainTableColumns = await getTableColumns(client, mainTableName);
+    const mainSelects = mainTableColumns.map(col => `"${mainTableName}"."${col}" AS "${col}"`);
+    const joinSelects = [];
+    for (const join of joinOperations) {
+        const joinColumns = await getTableColumns(client, join.from);
+        if (joinColumns.length === 0) {
+            continue;
+        }
+        for (const col of joinColumns) {
+            joinSelects.push(`${join.as}."${col}" AS "${join.as}__${col}"`);
+        }
+    }
+    const allSelects = [...mainSelects, ...joinSelects];
+    return allSelects.join(', ');
+}

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

@@ -0,0 +1,5 @@
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function buildWhereClause(queryObject: IQueryOptions, values?: any[], tablePrefix?: string): {
+    whereClause: string;
+    values: any[];
+};

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

@@ -0,0 +1,50 @@
+export function buildWhereClause(queryObject, values = [], tablePrefix) {
+    const filters = queryObject.filters || {};
+    const conditions = [];
+    let paramIndex = values.length + 1;
+    const qualifyColumn = (columnName) => {
+        return tablePrefix ? `"${tablePrefix}"."${columnName}"` : `"${columnName}"`;
+    };
+    for (const [key, value] of Object.entries(filters)) {
+        if (value) {
+            const qualifiedKey = qualifyColumn(key);
+            if (value.eq !== undefined) {
+                conditions.push(`${qualifiedKey} = $${paramIndex}`);
+                values.push(value.eq);
+                paramIndex++;
+            }
+            else if (value.in !== undefined && Array.isArray(value.in)) {
+                const placeholders = value.in.map(() => `$${paramIndex++}`).join(', ');
+                conditions.push(`${qualifiedKey} IN (${placeholders})`);
+                values.push(...value.in);
+            }
+            else if (value.gte !== undefined) {
+                conditions.push(`${qualifiedKey} >= $${paramIndex}`);
+                values.push(value.gte);
+                paramIndex++;
+            }
+            else if (value.lte !== undefined) {
+                conditions.push(`${qualifiedKey} <= $${paramIndex}`);
+                values.push(value.lte);
+                paramIndex++;
+            }
+            else if (value.gt !== undefined) {
+                conditions.push(`${qualifiedKey} > $${paramIndex}`);
+                values.push(value.gt);
+                paramIndex++;
+            }
+            else if (value.lt !== undefined) {
+                conditions.push(`${qualifiedKey} < $${paramIndex}`);
+                values.push(value.lt);
+                paramIndex++;
+            }
+            else if (value.contains !== undefined) {
+                conditions.push(`LOWER(${qualifiedKey}) LIKE LOWER($${paramIndex})`);
+                values.push(`%${value.contains}%`);
+                paramIndex++;
+            }
+        }
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    return { whereClause, values };
+}

package/dist/databases/postgres/utils/columns-and-values-from-entity.d.ts

@@ -0,0 +1,5 @@
+import { IEntity } from "@loomcore/common/models";
+export declare function columnsAndValuesFromEntity<T extends IEntity>(entity: Partial<T>): {
+    columns: string[];
+    values: any[];
+};

package/dist/databases/postgres/utils/columns-and-values-from-entity.js

@@ -0,0 +1,9 @@
+export function columnsAndValuesFromEntity(entity) {
+    const columns = [];
+    const values = [];
+    for (const [key, value] of Object.entries(entity)) {
+        columns.push(`"${key}"`);
+        values.push(value);
+    }
+    return { columns, values };
+}

package/dist/databases/postgres/utils/convert-null-to-undefined.util.d.ts

@@ -0,0 +1,2 @@
+import { TSchema } from '@sinclair/typebox';
+export declare function convertNullToUndefined<T>(data: T, schema: TSchema): T;

package/dist/databases/postgres/utils/convert-null-to-undefined.util.js

@@ -0,0 +1,70 @@
+import _ from 'lodash';
+function isPropertyOptional(key, schema) {
+    if (!schema || typeof schema !== 'object')
+        return false;
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+        for (const nestedSchema of schema.allOf) {
+            if (!isPropertyOptional(key, nestedSchema)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (schema.type === 'object' && schema.properties && schema.properties[key]) {
+        const required = schema.required || [];
+        return !required.includes(key);
+    }
+    return false;
+}
+export function convertNullToUndefined(data, schema) {
+    if (!data || !schema)
+        return data;
+    if (Array.isArray(data)) {
+        return data.map(item => convertNullToUndefined(item, schema));
+    }
+    if (typeof data !== 'object' || data === null) {
+        return data;
+    }
+    const clone = _.cloneDeep(data);
+    const processObject = (obj, subSchema) => {
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+            return;
+        if (subSchema.allOf && Array.isArray(subSchema.allOf)) {
+            for (const nestedSchema of subSchema.allOf) {
+                processObject(obj, nestedSchema);
+            }
+            return;
+        }
+        if (subSchema.type === 'object' && subSchema.properties) {
+            for (const [key, propSchema] of Object.entries(subSchema.properties)) {
+                if (!propSchema || typeof propSchema !== 'object')
+                    continue;
+                const typedPropSchema = propSchema;
+                const value = obj[key];
+                if (isPropertyOptional(key, subSchema)) {
+                    if (value === null) {
+                        delete obj[key];
+                    }
+                }
+                if (typedPropSchema.type === 'object' && value && typeof value === 'object' && !Array.isArray(value)) {
+                    processObject(value, typedPropSchema);
+                }
+                if (typedPropSchema.type === 'array' && Array.isArray(value)) {
+                    const items = typedPropSchema.items;
+                    if (items) {
+                        for (let i = 0; i < value.length; i++) {
+                            if (items.type === 'object' && value[i] && typeof value[i] === 'object' && !Array.isArray(value[i])) {
+                                processObject(value[i], items);
+                            }
+                            else if (items.type === 'array' && Array.isArray(value[i])) {
+                                value[i] = convertNullToUndefined(value[i], items);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    processObject(clone, schema);
+    return clone;
+}

package/dist/databases/postgres/utils/transform-join-results.d.ts

@@ -0,0 +1,2 @@
+import { Operation } from '../../operations/operation.js';
+export declare function transformJoinResults<T>(rows: any[], operations: Operation[]): T[];

package/dist/databases/postgres/utils/transform-join-results.js

@@ -0,0 +1,33 @@
+import { Join } from '../../operations/join.operation.js';
+export function transformJoinResults(rows, operations) {
+    const joinOperations = operations.filter(op => op instanceof Join);
+    if (joinOperations.length === 0) {
+        return rows;
+    }
+    return rows.map(row => {
+        const transformed = {};
+        for (const key of Object.keys(row)) {
+            const hasJoinPrefix = joinOperations.some(join => key.startsWith(`${join.as}__`));
+            if (!hasJoinPrefix) {
+                transformed[key] = row[key];
+            }
+        }
+        for (const join of joinOperations) {
+            const prefix = `${join.as}__`;
+            const joinedData = {};
+            let hasAnyData = false;
+            for (const key of Object.keys(row)) {
+                if (key.startsWith(prefix)) {
+                    const columnName = key.substring(prefix.length);
+                    const value = row[key];
+                    joinedData[columnName] = value;
+                    if (value !== null && value !== undefined) {
+                        hasAnyData = true;
+                    }
+                }
+            }
+            transformed[join.as] = hasAnyData ? joinedData : null;
+        }
+        return transformed;
+    });
+}

package/dist/databases/utils/get-property-schema.util.d.ts

@@ -0,0 +1,2 @@
+import { TSchema } from '@sinclair/typebox';
+export declare function getPropertySchema(key: string, schema: TSchema): TSchema | undefined;

package/dist/databases/utils/get-property-schema.util.js

@@ -0,0 +1,15 @@
+export function getPropertySchema(key, schema) {
+    if (!schema || typeof schema !== 'object')
+        return undefined;
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+        for (const nestedSchema of schema.allOf) {
+            const propSchema = getPropertySchema(key, nestedSchema);
+            if (propSchema)
+                return propSchema;
+        }
+    }
+    if (schema.type === 'object' && schema.properties) {
+        return schema.properties[key];
+    }
+    return undefined;
+}

package/dist/databases/utils/index.d.ts

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

package/dist/databases/utils/index.js

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

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

@@ -3,8 +3,9 @@ export interface IBaseApiConfig {
     env: string;
     hostName: string;
     clientSecret: string;
-    mongoDbUrl?: string;
-    databaseName?: string;
+    database: {
+        name?: string;
+    };
     externalPort?: number;
     internalPort?: number;
     corsAllowedOrigins: string[];

package/dist/models/index.d.ts

@@ -1,2 +1,2 @@
 export * from './base-api-config.interface.js';
-export * from './types/index.js';
+export * from './refresh-token.model.js';

package/dist/models/index.js

@@ -1,2 +1,2 @@
 export * from './base-api-config.interface.js';
-export * from './types/index.js';
+export * from './refresh-token.model.js';

package/dist/models/refresh-token.model.d.ts

@@ -0,0 +1,18 @@
+import { IEntity } from "@loomcore/common/models";
+export interface IRefreshToken extends IEntity {
+    token: string;
+    deviceId: string;
+    userId: string;
+    expiresOn: number;
+    created: Date;
+    createdBy: string;
+}
+export declare const refreshTokenSchema: import("@sinclair/typebox").TObject<{
+    token: import("@sinclair/typebox").TString;
+    deviceId: import("@sinclair/typebox").TString;
+    userId: import("@sinclair/typebox").TString;
+    expiresOn: import("@sinclair/typebox").TNumber;
+    created: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>, import("@sinclair/typebox").TUndefined]>;
+    createdBy: import("@sinclair/typebox").TString;
+}>;
+export declare const refreshTokenModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/models/refresh-token.model.js

@@ -0,0 +1,13 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { TypeboxIsoDate } from "@loomcore/common/validation";
+import { Type } from "@sinclair/typebox";
+;
+export const refreshTokenSchema = Type.Object({
+    token: Type.String({ minLength: 1 }),
+    deviceId: Type.String({ minLength: 1 }),
+    userId: Type.String({ minLength: 1 }),
+    expiresOn: Type.Number(),
+    created: TypeboxIsoDate({ title: 'Created Date' }),
+    createdBy: Type.String({ minLength: 1 })
+});
+export const refreshTokenModelSpec = entityUtils.getModelSpec(refreshTokenSchema);