@loomcore/api 0.0.58 → 0.1.0

package/dist/databases/mongo-db/queries/mongo-find.query.js

@@ -0,0 +1,9 @@
+import { buildNoSqlMatch, buildFindOptions } from "../utils/index.js";
+export async function find(db, queryObject, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const options = buildFindOptions(queryObject);
+    const entities = await collection.find(filter, options).toArray();
+    return entities;
+}

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

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

package/dist/databases/mongo-db/queries/mongo-get-all.query.js

@@ -0,0 +1,17 @@
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+export async function getAll(db, operations, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const pipeline = new NoSqlPipeline()
+        .addOperations(operations)
+        .build();
+    let aggregateResult;
+    if (pipeline.length === 0) {
+        const cursor = collection.find();
+        aggregateResult = await cursor.toArray();
+    }
+    else {
+        const cursor = collection.aggregate(pipeline);
+        aggregateResult = await cursor.toArray();
+    }
+    return aggregateResult;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { BadRequestError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+export async function getById(db, operations, queryObject, id, pluralResourceName) {
+    if (!entityUtils.isValidObjectId(id)) {
+        throw new BadRequestError('id is not a valid ObjectId');
+    }
+    const collection = db.collection(pluralResourceName);
+    queryObject.filters || (queryObject.filters = {});
+    queryObject.filters._id = { eq: id };
+    const pipeline = new NoSqlPipeline()
+        .addMatch(queryObject)
+        .addOperations(operations)
+        .build();
+    const entity = await collection.aggregate(pipeline).next();
+    return entity;
+}

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

@@ -0,0 +1,2 @@
+import { Db } from "mongodb";
+export declare function getCount(db: Db, pluralResourceName: string): Promise<number>;

package/dist/databases/mongo-db/queries/mongo-get-count.query.js

@@ -0,0 +1,5 @@
+export async function getCount(db, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const result = await collection.countDocuments();
+    return result;
+}

package/dist/databases/mongo-db/queries/mongo-get.query.d.ts

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

package/dist/databases/mongo-db/queries/mongo-get.query.js

@@ -0,0 +1,14 @@
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { apiUtils } from "../../../utils/api.utils.js";
+export async function get(db, operations, queryOptions, modelSpec, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const pipeline = new NoSqlPipeline()
+        .addMatch(queryOptions, modelSpec)
+        .addOperations(operations)
+        .addQueryOptions(queryOptions, true)
+        .build();
+    const cursor = collection.aggregate(pipeline);
+    const aggregateResult = await cursor.next();
+    const pagedResult = apiUtils.getPagedResult(aggregateResult?.data || [], aggregateResult?.total || 0, queryOptions);
+    return pagedResult;
+}

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

@@ -0,0 +1,3 @@
+import { FindOptions } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function buildFindOptions(queryOptions: IQueryOptions): FindOptions;

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

@@ -0,0 +1,15 @@
+export function buildFindOptions(queryOptions) {
+    let findOptions = {};
+    if (queryOptions) {
+        if (queryOptions.orderBy) {
+            findOptions.sort = {
+                [queryOptions.orderBy]: queryOptions.sortDirection === 'asc' ? 1 : -1
+            };
+        }
+        if (queryOptions.page && queryOptions.pageSize) {
+            findOptions.skip = (queryOptions.page - 1) * queryOptions.pageSize;
+            findOptions.limit = queryOptions.pageSize;
+        }
+    }
+    return findOptions;
+}

package/dist/databases/mongo-db/utils/build-no-sql-match.util.d.ts

@@ -0,0 +1,3 @@
+import { IQueryOptions, IModelSpec } from '@loomcore/common/models';
+import { Document } from 'mongodb';
+export declare function buildNoSqlMatch(queryOptions: IQueryOptions, modelSpec?: IModelSpec): Document;

package/dist/databases/mongo-db/utils/build-no-sql-match.util.js

@@ -0,0 +1,59 @@
+import { entityUtils } from '@loomcore/common/utils';
+import { ObjectId } from 'mongodb';
+import { PROPERTIES_THAT_ARE_NOT_OBJECT_IDS } from '../../models/constants.js';
+import { getPropertySchema } from '../../utils/get-property-schema.util.js';
+export function buildNoSqlMatch(queryOptions, modelSpec) {
+    const filters = queryOptions.filters || {};
+    const schema = modelSpec?.fullSchema;
+    let match = {};
+    for (const [key, value] of Object.entries(filters)) {
+        if (value) {
+            const propSchema = schema ? getPropertySchema(key, schema) : undefined;
+            if (value.eq !== undefined) {
+                const isObjectIdField = propSchema?.format === 'objectid';
+                const valueToCompare = value.eq;
+                if ((key === '_id' || isObjectIdField || (!schema && key.endsWith('Id') && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)))
+                    && typeof valueToCompare === 'string' && entityUtils.isValidObjectId(valueToCompare)) {
+                    match[key] = new ObjectId(valueToCompare);
+                }
+                else if (typeof valueToCompare === 'string' && !isNaN(Number(valueToCompare))) {
+                    match[key] = Number(valueToCompare);
+                }
+                else {
+                    match[key] = valueToCompare;
+                }
+            }
+            else if (value.in !== undefined && Array.isArray(value.in)) {
+                const isObjectIdArray = propSchema?.type === 'array' && propSchema.items?.format === 'objectid';
+                if (key === '_id' || isObjectIdArray || (!schema && (key.endsWith('Id') || key.endsWith('Ids')) && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key))) {
+                    const objectIds = value.in
+                        .filter(val => typeof val === 'string' && entityUtils.isValidObjectId(val))
+                        .map(val => new ObjectId(val));
+                    if (objectIds.length > 0) {
+                        match[key] = { $in: objectIds };
+                    }
+                }
+                else {
+                    const convertedValues = value.in.map(val => typeof val === 'string' && !isNaN(Number(val)) ? Number(val) : val);
+                    match[key] = { $in: convertedValues };
+                }
+            }
+            else if (value.gte !== undefined) {
+                match[key] = { $gte: value.gte };
+            }
+            else if (value.lte !== undefined) {
+                match[key] = { $lte: value.lte };
+            }
+            else if (value.gt !== undefined) {
+                match[key] = { $gt: value.gt };
+            }
+            else if (value.lt !== undefined) {
+                match[key] = { $lt: value.lt };
+            }
+            else if (value.contains !== undefined) {
+                match[key] = { $regex: value.contains, $options: 'i' };
+            }
+        }
+    }
+    return { $match: match };
+}

package/dist/databases/mongo-db/utils/convert-object-ids-to-strings.util.d.ts

@@ -0,0 +1 @@
+export declare function convertObjectIdsToStrings<T>(entity: T): T;

package/dist/databases/mongo-db/utils/convert-object-ids-to-strings.util.js

@@ -0,0 +1,32 @@
+import _ from 'lodash';
+import { ObjectId } from 'mongodb';
+export function convertObjectIdsToStrings(entity) {
+    if (!entity)
+        return entity;
+    const clone = _.cloneDeep(entity);
+    const processEntity = (obj) => {
+        if (!obj)
+            return obj;
+        if (obj instanceof ObjectId) {
+            return obj.toString();
+        }
+        if (obj instanceof Date) {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => processEntity(item));
+        }
+        if (typeof obj === 'object') {
+            const result = { ...obj };
+            for (const key of Object.keys(result)) {
+                const value = result[key];
+                if (value !== null && value !== undefined) {
+                    result[key] = processEntity(value);
+                }
+            }
+            return result;
+        }
+        return obj;
+    };
+    return processEntity(clone);
+}

package/dist/databases/mongo-db/utils/convert-operations-to-pipeline.util.d.ts

@@ -0,0 +1,3 @@
+import { Document } from 'mongodb';
+import { Operation } from '../../operations/operation.js';
+export declare function convertOperationsToPipeline(operations: Operation[]): Document[];

package/dist/databases/mongo-db/utils/convert-operations-to-pipeline.util.js

@@ -0,0 +1,68 @@
+import { Join } from '../../operations/join.operation.js';
+export function convertOperationsToPipeline(operations) {
+    let pipeline = [];
+    operations.forEach(operation => {
+        if (operation instanceof Join) {
+            const needsObjectIdConversion = operation.foreignField === '_id';
+            if (needsObjectIdConversion) {
+                pipeline.push({
+                    $lookup: {
+                        from: operation.from,
+                        let: { localId: { $cond: [
+                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
+                                    { $toObjectId: `$${operation.localField}` },
+                                    `$${operation.localField}`
+                                ] } },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $expr: {
+                                        $eq: [`$${operation.foreignField}`, '$$localId']
+                                    }
+                                }
+                            }
+                        ],
+                        as: `${operation.as}Arr`
+                    }
+                }, {
+                    $unwind: {
+                        path: `$${operation.as}Arr`,
+                        preserveNullAndEmptyArrays: true
+                    }
+                }, {
+                    $addFields: {
+                        [operation.as]: `$${operation.as}Arr`
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}Arr`]: 0
+                    }
+                });
+            }
+            else {
+                pipeline.push({
+                    $lookup: {
+                        from: operation.from,
+                        localField: operation.localField,
+                        foreignField: operation.foreignField,
+                        as: `${operation.as}Arr`
+                    }
+                }, {
+                    $unwind: {
+                        path: `$${operation.as}Arr`,
+                        preserveNullAndEmptyArrays: true
+                    }
+                }, {
+                    $addFields: {
+                        [operation.as]: `$${operation.as}Arr`
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}Arr`]: 0
+                    }
+                });
+            }
+        }
+    });
+    return pipeline;
+}

package/dist/databases/mongo-db/utils/convert-query-options-to-pipeline.util.d.ts

@@ -0,0 +1,3 @@
+import { IQueryOptions } from '@loomcore/common/models';
+import { Document } from 'mongodb';
+export declare function convertQueryOptionsToPipeline(queryOptions: IQueryOptions, pagination: boolean): Document[];

package/dist/databases/mongo-db/utils/convert-query-options-to-pipeline.util.js

@@ -0,0 +1,31 @@
+export function convertQueryOptionsToPipeline(queryOptions, pagination) {
+    let pipeline = [];
+    if (queryOptions.orderBy || (queryOptions.page && queryOptions.pageSize)) {
+        let results = [];
+        if (queryOptions.orderBy) {
+            results.push({
+                $sort: {
+                    [queryOptions.orderBy]: queryOptions.sortDirection === 'asc' ? 1 : -1
+                }
+            });
+        }
+        if (queryOptions.page && queryOptions.pageSize) {
+            results.push({ $skip: (queryOptions.page - 1) * queryOptions.pageSize });
+            results.push({ $limit: queryOptions.pageSize });
+        }
+        if (pagination) {
+            pipeline.push({
+                $facet: {
+                    data: results,
+                    count: [{ $count: 'total' }]
+                }
+            }, {
+                $project: {
+                    data: 1,
+                    total: { $arrayElemAt: ['$count.total', 0] }
+                }
+            });
+        }
+    }
+    return pipeline;
+}

package/dist/databases/mongo-db/utils/convert-strings-to-object-ids.util.d.ts

@@ -0,0 +1,3 @@
+import { TSchema } from '@sinclair/typebox';
+import { IEntity } from '@loomcore/common/models';
+export declare function convertStringsToObjectIds<U extends IEntity | Partial<IEntity>>(entity: U, schema: TSchema): U;

package/dist/databases/mongo-db/utils/convert-strings-to-object-ids.util.js

@@ -0,0 +1,72 @@
+import { entityUtils } from '@loomcore/common/utils';
+import _ from 'lodash';
+import { ObjectId } from 'mongodb';
+import { PROPERTIES_THAT_ARE_NOT_OBJECT_IDS } from '../../models/constants.js';
+export function convertStringsToObjectIds(entity, schema) {
+    if (!entity)
+        return entity;
+    const clone = _.cloneDeep(entity);
+    if (clone._id && typeof clone._id === 'string' && entityUtils.isValidObjectId(clone._id)) {
+        clone._id = new ObjectId(clone._id);
+    }
+    const processEntity = (obj, subSchema, path = []) => {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        if (obj instanceof Date) {
+            return obj;
+        }
+        if (subSchema.allOf && Array.isArray(subSchema.allOf)) {
+            let result = { ...obj };
+            for (const nestedSchema of subSchema.allOf) {
+                result = processEntity(result, nestedSchema, path);
+            }
+            return result;
+        }
+        if (Array.isArray(obj)) {
+            const items = subSchema.items;
+            if (!items)
+                return obj;
+            if (items.format === 'objectid') {
+                if (path.length === 1 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(path[0])) {
+                    return obj;
+                }
+                return obj.map(item => {
+                    if (typeof item === 'string' && entityUtils.isValidObjectId(item)) {
+                        return new ObjectId(item);
+                    }
+                    return item;
+                });
+            }
+            if (items.type === 'object') {
+                return obj.map((item, index) => processEntity(item, items, [...path, index.toString()]));
+            }
+            return obj;
+        }
+        const result = { ...obj };
+        if (subSchema.type === 'object' && subSchema.properties) {
+            for (const [key, propSchema] of Object.entries(subSchema.properties)) {
+                if (!propSchema || typeof propSchema !== 'object' || result[key] === null || result[key] === undefined) {
+                    continue;
+                }
+                const typedPropSchema = propSchema;
+                const fullPath = [...path, key];
+                const value = result[key];
+                const isObjectIdField = typedPropSchema.format === 'objectid';
+                if (isObjectIdField && path.length === 0 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
+                    continue;
+                }
+                if (isObjectIdField && typeof value === 'string' && entityUtils.isValidObjectId(value)) {
+                    result[key] = new ObjectId(value);
+                }
+                else if (typedPropSchema.type === 'array' && Array.isArray(value)) {
+                    result[key] = processEntity(value, typedPropSchema, fullPath);
+                }
+                else if (typedPropSchema.type === 'object' && typeof value === 'object' && !Array.isArray(value)) {
+                    result[key] = processEntity(value, typedPropSchema, fullPath);
+                }
+            }
+        }
+        return result;
+    };
+    return processEntity(clone, schema);
+}

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

@@ -0,0 +1,7 @@
+export * from './build-find-options.util.js';
+export * from './build-no-sql-match.util.js';
+export * from './convert-object-ids-to-strings.util.js';
+export * from './convert-operations-to-pipeline.util.js';
+export * from './convert-query-options-to-pipeline.util.js';
+export * from './convert-strings-to-object-ids.util.js';
+export * from '../models/no-sql-pipeline.js';

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

@@ -0,0 +1,7 @@
+export * from './build-find-options.util.js';
+export * from './build-no-sql-match.util.js';
+export * from './convert-object-ids-to-strings.util.js';
+export * from './convert-operations-to-pipeline.util.js';
+export * from './convert-query-options-to-pipeline.util.js';
+export * from './convert-strings-to-object-ids.util.js';
+export * from '../models/no-sql-pipeline.js';

package/dist/databases/operations/join.operation.d.ts

@@ -0,0 +1,7 @@
+export declare class Join {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as: string;
+    constructor(from: string, localField: string, foreignField: string, as: string);
+}

package/dist/databases/operations/join.operation.js

@@ -0,0 +1,12 @@
+export class Join {
+    from;
+    localField;
+    foreignField;
+    as;
+    constructor(from, localField, foreignField, as) {
+        this.from = from;
+        this.localField = localField;
+        this.foreignField = foreignField;
+        this.as = as;
+    }
+}

package/dist/databases/operations/operation.d.ts

@@ -0,0 +1,2 @@
+import { Join } from "./join.operation.js";
+export type Operation = Join;

package/dist/databases/postgres/commands/postgres-batch-update.command.d.ts

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

package/dist/databases/postgres/commands/postgres-batch-update.command.js

@@ -0,0 +1,56 @@
+import { Join } from "../../operations/join.operation.js";
+import { BadRequestError } from "../../../errors/index.js";
+import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
+import { buildWhereClause } from '../utils/build-where-clause.js';
+export async function batchUpdate(client, entities, operations, queryObject, pluralResourceName) {
+    if (!entities || entities.length === 0) {
+        return [];
+    }
+    const entityIds = [];
+    for (const entity of entities) {
+        if (!entity._id || typeof entity._id !== 'string') {
+            throw new BadRequestError('Each entity in a batch update must have a valid _id.');
+        }
+        entityIds.push(entity._id);
+    }
+    queryObject.filters = queryObject.filters || {};
+    try {
+        await client.query('BEGIN');
+        for (const entity of entities) {
+            const { _id, ...updateData } = entity;
+            if (Object.keys(updateData).length === 0) {
+                continue;
+            }
+            const { columns, values } = columnsAndValuesFromEntity(updateData);
+            const setClause = columns.map((col, index) => `${col} = $${index + 1}`).join(', ');
+            queryObject.filters._id = { eq: _id };
+            const { whereClause } = buildWhereClause(queryObject, values);
+            const query = `
+                UPDATE "${pluralResourceName}"
+                SET ${setClause}
+                ${whereClause}
+            `;
+            await client.query(query, values);
+        }
+        await client.query('COMMIT');
+        const joinClauses = buildJoinClauses(operations, pluralResourceName);
+        const hasJoins = operations.some(op => op instanceof Join);
+        const tablePrefix = hasJoins ? pluralResourceName : undefined;
+        queryObject.filters._id = { in: entityIds };
+        const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            ${whereClause}
+        `;
+        const result = await client.query(selectQuery, values);
+        return result.rows;
+    }
+    catch (err) {
+        await client.query('ROLLBACK');
+        if (err.code === '23505') {
+            throw new BadRequestError(`One or more ${pluralResourceName} have duplicate key violations`);
+        }
+        throw new BadRequestError(`Error updating ${pluralResourceName}: ${err.message}`);
+    }
+}

package/dist/databases/postgres/commands/postgres-create-many.command.d.ts

@@ -0,0 +1,6 @@
+import { Client } from 'pg';
+import { IEntity } from '@loomcore/common/models';
+export declare function createMany<T extends IEntity>(client: Client, pluralResourceName: string, entities: Partial<T>[]): Promise<{
+    insertedIds: string[];
+    entities: T[];
+}>;

package/dist/databases/postgres/commands/postgres-create-many.command.js

@@ -0,0 +1,63 @@
+import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
+import { randomUUID } from 'crypto';
+export async function createMany(client, pluralResourceName, entities) {
+    if (entities.length === 0) {
+        return {
+            insertedIds: [],
+            entities: []
+        };
+    }
+    try {
+        const entitiesWithIds = entities.map(entity => {
+            entity._id = entity._id ?? randomUUID().toString();
+            return entity;
+        });
+        const tableColumns = await client.query(`
+                SELECT column_name, column_default
+                FROM information_schema.columns
+                WHERE table_schema = current_schema()
+                  AND table_name = $1
+                ORDER BY ordinal_position
+            `, [pluralResourceName]);
+        if (tableColumns.rows.length === 0) {
+            throw new BadRequestError(`Unable to resolve columns for ${pluralResourceName}`);
+        }
+        const allValues = [];
+        const valueClauses = [];
+        entitiesWithIds.forEach((entity, entityIndex) => {
+            const objectEntries = Object.entries(entity);
+            const values = tableColumns.rows.map(column => {
+                if (objectEntries.find(entry => entry[0] === column.column_name)) {
+                    return objectEntries.find(entry => entry[0] === column.column_name)?.[1];
+                }
+                return column.column_default;
+            });
+            const placeholders = values.map((_, valueIndex) => {
+                const paramIndex = entityIndex * values.length + valueIndex + 1;
+                return `$${paramIndex}`;
+            }).join(', ');
+            valueClauses.push(`(${placeholders})`);
+            allValues.push(...values);
+        });
+        const query = `
+            INSERT INTO "${pluralResourceName}" (${tableColumns.rows.map(column => `"${column.column_name}"`).join(', ')})
+            VALUES ${valueClauses.join(', ')}
+            RETURNING _id
+        `;
+        const result = await client.query(query, allValues);
+        if (result.rows.length !== entitiesWithIds.length) {
+            throw new BadRequestError(`Error creating ${pluralResourceName}: Expected ${entitiesWithIds.length} rows, got ${result.rows.length}`);
+        }
+        const insertedIds = result.rows.map(row => row._id);
+        return {
+            insertedIds,
+            entities: entitiesWithIds
+        };
+    }
+    catch (err) {
+        if (err.code === '23505') {
+            throw new DuplicateKeyError(`One or more ${pluralResourceName} already exist`);
+        }
+        throw new BadRequestError(`Error creating ${pluralResourceName}: ${err.message}`);
+    }
+}

package/dist/databases/postgres/commands/postgres-create.command.d.ts

@@ -0,0 +1,6 @@
+import { Client } from 'pg';
+import { IEntity } from "@loomcore/common/models";
+export declare function create<T extends IEntity>(client: Client, pluralResourceName: string, entity: Partial<T>): Promise<{
+    insertedId: string;
+    entity: T;
+}>;

package/dist/databases/postgres/commands/postgres-create.command.js

@@ -0,0 +1,29 @@
+import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
+import { randomUUID } from 'crypto';
+import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
+export async function create(client, pluralResourceName, entity) {
+    try {
+        entity._id = entity._id ?? randomUUID().toString();
+        const { columns, values } = columnsAndValuesFromEntity(entity);
+        const placeholders = columns.map((_, index) => `$${index + 1}`).join(', ');
+        const query = `
+            INSERT INTO "${pluralResourceName}" (${columns.join(', ')})
+            VALUES (${placeholders})
+            RETURNING _id
+        `;
+        const result = await client.query(query, values);
+        if (result.rows.length === 0) {
+            throw new BadRequestError(`Error creating ${pluralResourceName}: No row returned`);
+        }
+        return {
+            insertedId: entity._id,
+            entity: entity
+        };
+    }
+    catch (err) {
+        if (err.code === '23505') {
+            throw new DuplicateKeyError(`${pluralResourceName} already exists`);
+        }
+        throw new BadRequestError(`Error creating ${pluralResourceName}: ${err.message}`);
+    }
+}

package/dist/databases/postgres/commands/postgres-delete-by-id.command.d.ts

@@ -0,0 +1,3 @@
+import { Client } from 'pg';
+import { DeleteResult } from "../../models/delete-result.js";
+export declare function deleteById(client: Client, id: string, pluralResourceName: string): Promise<DeleteResult>;

package/dist/databases/postgres/commands/postgres-delete-by-id.command.js

@@ -0,0 +1,6 @@
+import { DeleteResult } from "../../models/delete-result.js";
+export async function deleteById(client, id, pluralResourceName) {
+    const query = `DELETE FROM "${pluralResourceName}" WHERE "_id" = $1`;
+    const result = await client.query(query, [id]);
+    return new DeleteResult(true, result.rowCount || 0);
+}

package/dist/databases/postgres/commands/postgres-delete-many.command.d.ts

@@ -0,0 +1,4 @@
+import { Client } from 'pg';
+import { IQueryOptions } from "@loomcore/common/models";
+import { DeleteResult } from "../../models/delete-result.js";
+export declare function deleteMany(client: Client, queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;