@loomcore/api 0.1.69 → 0.1.71

package/dist/__tests__/postgres-test-migrations/postgres-test-schema.js

@@ -123,7 +123,30 @@ export const getPostgresTestSchema = (config) => {
         }
     });
     migrations.push({
-        name: '00000000000104_schema-clients',
+        name: '00000000000105_5_schema-agents',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "agents" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "person_id" INTEGER NOT NULL UNIQUE,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_agents_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "agents"');
+        }
+    });
+    migrations.push({
+        name: '00000000000105_6_schema-clients',
         up: async ({ context: pool }) => {
             const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
             await pool.query(`
@@ -132,13 +155,15 @@ export const getPostgresTestSchema = (config) => {
           ${orgColumnDef}
           "external_id" VARCHAR UNIQUE,
           "person_id" INTEGER NOT NULL UNIQUE,
+          "agent_id" INTEGER,
           "_created" TIMESTAMPTZ NOT NULL,
           "_createdBy" INTEGER NOT NULL,
           "_updated" TIMESTAMPTZ NOT NULL,
           "_updatedBy" INTEGER NOT NULL,
           "_deleted" TIMESTAMPTZ,
           "_deletedBy" INTEGER,
-          CONSTRAINT fk_clients_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE
+          CONSTRAINT fk_clients_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE,
+          CONSTRAINT fk_clients_agent_id FOREIGN KEY ("agent_id") REFERENCES agents("_id") ON DELETE SET NULL
         )
       `);
         },

package/dist/controllers/index.d.ts

@@ -1,4 +1,5 @@
 export * from './api.controller.js';
+export * from './query-api.controller.js';
 export * from './auth.controller.js';
 export * from './organizations.controller.js';
 export * from './users.controller.js';

package/dist/controllers/index.js

@@ -1,4 +1,5 @@
 export * from './api.controller.js';
+export * from './query-api.controller.js';
 export * from './auth.controller.js';
 export * from './organizations.controller.js';
 export * from './users.controller.js';

package/dist/controllers/query-api.controller.d.ts

@@ -0,0 +1,19 @@
+import { Application, NextFunction, Request, Response } from 'express';
+import { IEntity, IModelSpec } from '@loomcore/common/models';
+import type { TSchema } from '@sinclair/typebox';
+import { IGenericQueryService } from '../services/index.js';
+export declare abstract class QueryApiController<T extends IEntity> {
+    protected app: Application;
+    protected service: IGenericQueryService<T>;
+    protected slug: string;
+    protected apiResourceName: string;
+    protected modelSpec?: IModelSpec;
+    protected publicSpec?: IModelSpec;
+    protected idSchema: TSchema;
+    protected constructor(slug: string, app: Application, service: IGenericQueryService<T>, resourceName?: string, modelSpec?: IModelSpec, publicSpec?: IModelSpec);
+    mapRoutes(app: Application): void;
+    getAll(req: Request, res: Response, next: NextFunction): Promise<void>;
+    get(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getById(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getCount(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/dist/controllers/query-api.controller.js

@@ -0,0 +1,61 @@
+import { BadRequestError } from '../errors/index.js';
+import { Value } from '@sinclair/typebox/value';
+import { getIdSchema } from '@loomcore/common/validation';
+import { apiUtils } from '../utils/index.js';
+import { isAuthorized } from '../middleware/index.js';
+export class QueryApiController {
+    app;
+    service;
+    slug;
+    apiResourceName;
+    modelSpec;
+    publicSpec;
+    idSchema;
+    constructor(slug, app, service, resourceName = '', modelSpec, publicSpec) {
+        this.slug = slug;
+        this.app = app;
+        this.service = service;
+        this.apiResourceName = resourceName;
+        this.modelSpec = modelSpec;
+        this.publicSpec = publicSpec;
+        this.idSchema = getIdSchema();
+        this.mapRoutes(app);
+    }
+    mapRoutes(app) {
+        app.get(`/api/${this.slug}`, isAuthorized(), this.get.bind(this));
+        app.get(`/api/${this.slug}/all`, isAuthorized(), this.getAll.bind(this));
+        app.get(`/api/${this.slug}/count`, isAuthorized(), this.getCount.bind(this));
+        app.get(`/api/${this.slug}/:id`, isAuthorized(), this.getById.bind(this));
+    }
+    async getAll(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const entities = await this.service.getAll(req.userContext);
+        apiUtils.apiResponse(res, 200, { data: entities }, this.modelSpec, this.publicSpec);
+    }
+    async get(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const queryOptions = apiUtils.getQueryOptionsFromRequest(req);
+        const pagedResult = await this.service.get(req.userContext, queryOptions);
+        apiUtils.apiResponse(res, 200, { data: pagedResult }, this.modelSpec, this.publicSpec);
+    }
+    async getById(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const idParam = req.params?.id;
+        if (!idParam) {
+            throw new BadRequestError('ID parameter is required');
+        }
+        try {
+            const id = Value.Convert(this.idSchema, idParam);
+            const entity = await this.service.getById(req.userContext, id);
+            apiUtils.apiResponse(res, 200, { data: entity }, this.modelSpec, this.publicSpec);
+        }
+        catch (error) {
+            throw new BadRequestError(`Invalid ID format: ${error.message || error}`);
+        }
+    }
+    async getCount(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const count = await this.service.getCount(req.userContext);
+        apiUtils.apiResponse(res, 200, { data: count }, this.modelSpec, this.publicSpec);
+    }
+}

package/dist/databases/operations/__tests__/models/agent.model.d.ts

@@ -0,0 +1,25 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+import { IPersonModel } from "./person.model.js";
+export interface IAgentModel extends IEntity, IAuditable {
+    person_id: number;
+    agent_person?: IPersonModel;
+}
+export declare const agentSchema: import("@sinclair/typebox").TObject<{
+    person_id: import("@sinclair/typebox").TNumber;
+    agent_person: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        first_name: import("@sinclair/typebox").TString;
+        middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        last_name: import("@sinclair/typebox").TString;
+        phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            phone_number: import("@sinclair/typebox").TString;
+            phone_number_type: import("@sinclair/typebox").TString;
+            is_default: import("@sinclair/typebox").TBoolean;
+        }>>;
+        email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            person_id: import("@sinclair/typebox").TNumber;
+            email_address: import("@sinclair/typebox").TString;
+            is_default: import("@sinclair/typebox").TBoolean;
+        }>>;
+    }>>;
+}>;
+export declare const agentModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/agent.model.js

@@ -0,0 +1,8 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { personSchema } from "./person.model.js";
+export const agentSchema = Type.Object({
+    person_id: Type.Number(),
+    agent_person: Type.Optional(personSchema),
+});
+export const agentModelSpec = entityUtils.getModelSpec(agentSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/client-report.model.d.ts

@@ -1,10 +1,12 @@
 import { IPersonModel } from "./person.model.js";
+import { IAgentModel } from "./agent.model.js";
 import type { IAuditable, IEntity } from "@loomcore/common/models";
 export interface IClientReportsModel extends IEntity, IAuditable {
-    person: IPersonModel;
+    client_person: IPersonModel;
+    agent?: IAgentModel;
 }
 export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
-    person: import("@sinclair/typebox").TObject<{
+    client_person: import("@sinclair/typebox").TObject<{
         first_name: import("@sinclair/typebox").TString;
         middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         last_name: import("@sinclair/typebox").TString;
@@ -19,5 +21,23 @@ export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
             is_default: import("@sinclair/typebox").TBoolean;
         }>>;
     }>;
+    agent: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        person_id: import("@sinclair/typebox").TNumber;
+        agent_person: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            first_name: import("@sinclair/typebox").TString;
+            middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            last_name: import("@sinclair/typebox").TString;
+            phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                phone_number: import("@sinclair/typebox").TString;
+                phone_number_type: import("@sinclair/typebox").TString;
+                is_default: import("@sinclair/typebox").TBoolean;
+            }>>;
+            email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                person_id: import("@sinclair/typebox").TNumber;
+                email_address: import("@sinclair/typebox").TString;
+                is_default: import("@sinclair/typebox").TBoolean;
+            }>>;
+        }>>;
+    }>>;
 }>;
 export declare const clientReportsModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/client-report.model.js

@@ -1,7 +1,9 @@
 import { personSchema } from "./person.model.js";
+import { agentSchema } from "./agent.model.js";
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
 export const clientReportsSchema = Type.Object({
-    person: personSchema
+    client_person: personSchema,
+    agent: Type.Optional(agentSchema)
 });
 export const clientReportsModelSpec = entityUtils.getModelSpec(clientReportsSchema, { isAuditable: true });

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

@@ -7,9 +7,16 @@ export function buildJoinClauses(operations, mainTableName) {
     const joinManyOperations = operations.filter(op => op instanceof JoinMany);
     const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
     for (const operation of joinOperations) {
-        const localFieldRef = mainTableName
-            ? `"${mainTableName}"."${operation.localField}"`
-            : `"${operation.localField}"`;
+        let localFieldRef;
+        if (operation.localField.includes('.')) {
+            const [tableAlias, columnName] = operation.localField.split('.');
+            localFieldRef = `${tableAlias}."${columnName}"`;
+        }
+        else {
+            localFieldRef = mainTableName
+                ? `"${mainTableName}"."${operation.localField}"`
+                : `"${operation.localField}"`;
+        }
         joinClauses += ` LEFT JOIN "${operation.from}" AS ${operation.as} ON ${localFieldRef} = "${operation.as}"."${operation.foreignField}"`;
     }
     for (const joinMany of joinManyOperations) {

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

@@ -36,7 +36,24 @@ export function transformJoinResults(rows, operations) {
                     }
                 }
             }
-            transformed[join.as] = hasAnyData ? joinedData : null;
+            if (join.localField.includes('.')) {
+                const [tableAlias] = join.localField.split('.');
+                const relatedJoin = joinOperations.find(j => j.as === tableAlias);
+                if (relatedJoin && transformed[relatedJoin.as] !== undefined && transformed[relatedJoin.as] !== null) {
+                    if (hasAnyData) {
+                        transformed[relatedJoin.as][join.as] = joinedData;
+                    }
+                    else {
+                        transformed[relatedJoin.as][join.as] = null;
+                    }
+                }
+                else {
+                    transformed[join.as] = hasAnyData ? joinedData : null;
+                }
+            }
+            else {
+                transformed[join.as] = hasAnyData ? joinedData : null;
+            }
         }
         for (const joinMany of joinManyOperations) {
             const jsonValue = row[joinMany.as];

package/dist/services/generic-query-service/generic-query-service.interface.d.ts

@@ -11,4 +11,5 @@ export interface IGenericQueryService<T extends IEntity> {
     getAll(userContext: IUserContext): Promise<T[]>;
     get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: AppIdType): Promise<T>;
+    getCount(userContext: IUserContext): Promise<number>;
 }

package/dist/services/generic-query-service/generic-query.service.d.ts

@@ -18,4 +18,5 @@ export declare class GenericQueryService<T extends IEntity> implements IGenericQ
     getAll(userContext: IUserContext): Promise<T[]>;
     get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: AppIdType): Promise<T>;
+    getCount(userContext: IUserContext): Promise<number>;
 }

package/dist/services/generic-query-service/generic-query.service.js

@@ -44,4 +44,8 @@ export class GenericQueryService {
         }
         return this.postProcessEntity(userContext, entity);
     }
+    async getCount(userContext) {
+        const { operations } = this.prepareQuery(userContext, {}, []);
+        return await this.database.getCount(this.rootTableName);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {