@clairejs/server 3.15.1 → 3.16.0

package/dist/http/repository/AbstractRepository.js

@@ -0,0 +1,26 @@
+import { getObjectMetadata } from "@clairejs/core";
+export class AbstractRepository {
+    model;
+    modelMetadata;
+    constructor(model) {
+        this.model = model;
+        this.modelMetadata = getObjectMetadata(this.model);
+    }
+    async beforeCreating(principal, records) {
+        //-- check for fields that has URI with mapper property
+        for (const record of records) {
+            for (const field of this.modelMetadata.fields) {
+                if (field.userResolver && principal) {
+                    //-- resolve user from principal
+                    record[field.name] = field.userResolver(principal);
+                }
+            }
+        }
+    }
+    project(records, projection) {
+        if (!projection) {
+            return records;
+        }
+        return records.map((re) => projection.reduce((collector, fieldName) => Object.assign(collector, { [fieldName]: re[fieldName] }), {}));
+    }
+}

package/dist/http/repository/DtoRepository.d.ts

@@ -3,7 +3,7 @@ import { IQueryProvider, ITransaction, QueryCondition } from "@clairejs/orm";
 import { IPrincipal } from "../../common/auth/IPrincipal";
 import { AbstractRepository } from "./AbstractRepository";
 import { ICrudRepository } from "./ICrudRepository";
-export declare type DtoDissolver<R extends Identifiable, K extends Identifiable> = (t: DeepPartial<K>) => MappingMetadata<R, any>[];
+export type DtoDissolver<R extends Identifiable, K extends Identifiable> = (t: DeepPartial<K>) => MappingMetadata<R, any>[];
 export interface MappingMetadata<R extends Identifiable, K extends AbstractModel> {
     multiple: boolean;
     modelClass: Constructor<K>;
@@ -12,7 +12,7 @@ export interface MappingMetadata<R extends Identifiable, K extends AbstractModel
     rootMapping: (ks?: DeepPartial<K>[]) => DeepPartial<R>;
     nestedMapping?: DtoDissolver<R, K>;
 }
-export declare const SingleMap: <R extends Identifiable<string | number>, K extends AbstractModel>(modelClass: Constructor<K>, forwardOps: (ops?: QueryCondition<R>[] | undefined) => QueryCondition<K>[] | undefined, forwardMapping: (t: DeepPartial<K>) => DeepPartial<K> | undefined, rootMapping: (k?: DeepPartial<K> | undefined) => DeepPartial<R>, nestedMapping?: DtoDissolver<R, K> | undefined) => {
+export declare const SingleMap: <R extends Identifiable, K extends AbstractModel>(modelClass: Constructor<K>, forwardOps: (ops?: QueryCondition<R>[] | undefined) => QueryCondition<K>[] | undefined, forwardMapping: (t: DeepPartial<K>) => DeepPartial<K> | undefined, rootMapping: (k?: DeepPartial<K> | undefined) => DeepPartial<R>, nestedMapping?: DtoDissolver<R, K> | undefined) => {
     multiple: boolean;
     modelClass: Constructor<K>;
     forwardOps: (ops?: QueryCondition<R>[] | undefined) => QueryCondition<K>[] | undefined;
@@ -20,7 +20,7 @@ export declare const SingleMap: <R extends Identifiable<string | number>, K exte
     rootMapping: (ks?: DeepPartial<K>[] | undefined) => DeepPartial<R>;
     nestedMapping: DtoDissolver<R, K> | undefined;
 };
-export declare const MultipleMap: <R extends Identifiable<string | number>, K extends AbstractModel>(modelClass: Constructor<K>, forwardOps: (ops?: QueryCondition<R>[] | undefined) => QueryCondition<K>[] | undefined, forwardMapping: (t: DeepPartial<K>[]) => DeepPartial<K>[] | undefined, rootMapping: (ks?: DeepPartial<K>[] | undefined) => DeepPartial<R>, nestedMapping?: DtoDissolver<R, K> | undefined) => {
+export declare const MultipleMap: <R extends Identifiable, K extends AbstractModel>(modelClass: Constructor<K>, forwardOps: (ops?: QueryCondition<R>[] | undefined) => QueryCondition<K>[] | undefined, forwardMapping: (t: DeepPartial<K>[]) => DeepPartial<K>[] | undefined, rootMapping: (ks?: DeepPartial<K>[] | undefined) => DeepPartial<R>, nestedMapping?: DtoDissolver<R, K> | undefined) => {
     multiple: boolean;
     modelClass: Constructor<K>;
     forwardOps: (ops?: QueryCondition<R>[] | undefined) => QueryCondition<K>[] | undefined;

package/dist/http/repository/DtoRepository.js

@@ -0,0 +1,204 @@
+import { deepMerge, Errors, } from "@clairejs/core";
+import { AbstractRepository } from "./AbstractRepository";
+import { ModelRepository } from "./ModelRepository";
+export const SingleMap = (modelClass, forwardOps, forwardMapping, rootMapping, nestedMapping) => ({
+    multiple: false,
+    modelClass,
+    forwardOps,
+    forwardMapping: (t) => {
+        const v = forwardMapping(t[0] || {});
+        return v && [v];
+    },
+    rootMapping: (ks) => {
+        const k = ks && ks[0];
+        return rootMapping(k);
+    },
+    nestedMapping,
+});
+export const MultipleMap = (modelClass, forwardOps, forwardMapping, rootMapping, nestedMapping) => ({
+    multiple: true,
+    modelClass,
+    forwardOps,
+    forwardMapping,
+    rootMapping,
+    nestedMapping,
+});
+export class DtoRepository extends AbstractRepository {
+    model;
+    dissolver;
+    constructor(model, dissolver) {
+        super(model);
+        this.model = model;
+        this.dissolver = dissolver;
+    }
+    async getMapValue(root, currentInstancesResolver, mappers, preOperator, postOperator) {
+        for (const mapper of mappers) {
+            const currentInstances = await currentInstancesResolver(mapper);
+            let instances = preOperator
+                ? await preOperator(mapper, mapper.forwardMapping(currentInstances), currentInstances)
+                : mapper.forwardMapping(currentInstances);
+            if (mapper.nestedMapping && instances) {
+                //-- resolve nested
+                for (const instance of instances) {
+                    await this.getMapValue(root, currentInstancesResolver, mapper.nestedMapping(instance), preOperator, postOperator);
+                }
+            }
+            if (postOperator) {
+                instances = await postOperator(mapper, mapper.forwardMapping(currentInstances), currentInstances);
+            }
+            //-- backward assign
+            const partial = mapper.rootMapping(instances);
+            deepMerge(root, partial);
+        }
+    }
+    async createMany({ principal, body, tx, }) {
+        const result = [];
+        await this.beforeCreating(principal, body.records);
+        for (const record of body.records) {
+            await this.getMapValue(record, async (mapper) => {
+                const repo = new ModelRepository(mapper.modelClass);
+                const currentInstances = await repo.getMany({
+                    ops: mapper.forwardOps(),
+                    queryProvider: tx,
+                });
+                return currentInstances.records;
+            }, this.dissolver(record), async (mapper, ks, currentInstances) => {
+                if (!ks) {
+                    return [];
+                }
+                const repo = new ModelRepository(mapper.modelClass);
+                const ops = mapper.forwardOps();
+                if (mapper.multiple) {
+                    //-- if ks contain an array of instances, we need to remove old instances and create new ones
+                    await repo.deleteMany({ ops, tx });
+                    //-- try creating new
+                    const createManyResult = await repo.createMany({ principal, body: { records: ks }, tx });
+                    return createManyResult.records;
+                }
+                else {
+                    //-- single mapping, we need to update record if found
+                    const k = ks[0];
+                    if (!k) {
+                        return [];
+                    }
+                    if (currentInstances.length === 0) {
+                        //-- record not found, create new
+                        const instances = await repo.createMany({
+                            principal,
+                            body: { records: ks },
+                            tx,
+                        });
+                        return instances.records;
+                    }
+                    else if (currentInstances.length === 1) {
+                        const result = await repo.updateMany({ principal, ops, body: { update: k }, tx });
+                        return [{ ...currentInstances[0], ...k, ...result.modified[0] }];
+                    }
+                    else {
+                        throw Errors.VALIDATION_ERROR(`Found multiple record when creating ${mapper.modelClass.name}`);
+                    }
+                }
+            });
+            result.push(record);
+        }
+        return { records: result };
+    }
+    async updateMany({ principal, queries, ops, body, tx, }) {
+        //-- check queries for id field
+        if (!queries?.fields?.id || queries.fields.id.length !== 1) {
+            throw Errors.VALIDATION_ERROR("Missing required id field in query");
+        }
+        const result = { ...body.update, id: queries.fields.id[0] };
+        await this.beforeCreating(principal, [result]);
+        await this.getMapValue(result, async (mapper) => {
+            const repo = new ModelRepository(mapper.modelClass);
+            const currentInstances = await repo.getMany({
+                ops: mapper.forwardOps(ops),
+                queryProvider: tx,
+            });
+            return currentInstances.records;
+        }, this.dissolver(result), async (mapper, ks, currentInstances) => {
+            if (!ks) {
+                return [];
+            }
+            const repo = new ModelRepository(mapper.modelClass);
+            const opsx = mapper.forwardOps(ops);
+            if (mapper.multiple) {
+                //-- if ks contain an array of instances, we need to remove old instances and create new ones
+                await repo.deleteMany({ ops: opsx, tx });
+                //-- try creating new
+                const createManyResult = await repo.createMany({ principal, body: { records: ks }, tx });
+                return createManyResult.records;
+            }
+            else {
+                //-- if ks contain only one instance, we only need to update that instance
+                const k = ks[0];
+                if (!k) {
+                    return [];
+                }
+                if (currentInstances.length == 0) {
+                    //-- record not found, return empty array
+                    return [];
+                }
+                if (currentInstances.length > 1) {
+                    //-- remove all instances
+                    await repo.deleteMany({ ops: opsx, tx });
+                    //-- try creating new
+                    await repo.createMany({ principal, body: { records: [k] }, tx });
+                }
+                else {
+                    //-- update current instance
+                    await repo.updateMany({ principal, ops: opsx, body: { update: k }, tx });
+                }
+                return currentInstances.map((re) => ({ ...re, ...k }));
+            }
+        });
+        let projection = ["id"];
+        if (queries.returning) {
+            //-- return result
+            projection = [
+                ...projection,
+                ...Object.keys(body.update).filter((key) => body.update[key] !== undefined),
+            ];
+        }
+        return { modified: result.id ? this.project([result], projection) : [] };
+    }
+    async getMany({ queries, ops, queryProvider, }) {
+        //-- check queries for id field
+        if (!queries?.fields?.id || queries.fields.id.length !== 1) {
+            throw Errors.VALIDATION_ERROR("Missing required id field in query");
+        }
+        const result = { id: queries.fields.id[0] };
+        await this.getMapValue(result, async () => [], this.dissolver(result), async (mapper) => {
+            const repo = new ModelRepository(mapper.modelClass);
+            //-- forward get
+            const instances = await repo.getMany({
+                ops: mapper.forwardOps(ops),
+                queryProvider,
+            });
+            return instances.records;
+        });
+        return result.id
+            ? { records: this.project([result], queries.projection), total: 1 }
+            : { records: [], total: 0 };
+    }
+    async deleteMany({ queries, ops, tx, }) {
+        //-- check queries for id field
+        if (!queries?.fields?.id || queries.fields.id.length !== 1) {
+            throw Errors.VALIDATION_ERROR("Missing required id field in query");
+        }
+        const result = { id: queries.fields.id[0] };
+        await this.getMapValue(result, async () => [], this.dissolver(result), undefined, async (mapper) => {
+            const repo = new ModelRepository(mapper.modelClass);
+            //const nestedQueries = mapper.forwardQuery();
+            const nestedOps = mapper.forwardOps(ops);
+            const result = await repo.deleteMany({
+                queries: { returning: queries?.returning },
+                ops: nestedOps,
+                tx,
+            });
+            return result.modified;
+        });
+        return { modified: result.id ? [result] : [] };
+    }
+}

package/dist/http/repository/ICrudRepository.js

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