@loomcore/api 0.1.116 → 0.1.118

package/dist/__tests__/common-test.utils.d.ts

@@ -7,6 +7,7 @@ import { GenericApiService } from '../services/index.js';
 import { IDatabase } from '../databases/models/index.js';
 import { ICategory } from './models/category.model.js';
 import { IProduct } from './models/product.model.js';
+import { IProductWithCategory } from './models/product-with-category.model.js';
 import { DbType } from '../databases/db-type.type.js';
 declare function initialize(database: IDatabase): void;
 declare function getRandomId(): string;
@@ -30,7 +31,7 @@ export declare class CategoryController extends ApiController<ICategory> {
     constructor(app: Application, database: IDatabase);
 }
 export declare function setupTestConfig(isMultiTenant: boolean | undefined, dbType: DbType): void;
-export declare class ProductService extends GenericApiService<IProduct> {
+export declare class ProductService extends GenericApiService<IProductWithCategory> {
     constructor(database: IDatabase);
 }
 export declare class ProductsController extends ApiController<IProduct> {

package/dist/__tests__/common-test.utils.js

@@ -238,7 +238,7 @@ const prepareQueryCustom = (userContext, queryObject, operations) => {
         queryObject: queryObject,
         operations: [
             ...operations,
-            new LeftJoin('categories', 'categoryId', '_id', 'category')
+            new LeftJoin('categories', 'category_id', '_id', 'category')
         ]
     };
 };

package/dist/__tests__/models/product-with-category.model.d.ts

@@ -1,21 +1,19 @@
 import { ICategory } from "./category.model.js";
-import { IAuditable, IEntity } from "@loomcore/common/models";
-export interface IProductWithCategory extends IEntity, IAuditable {
-    name: string;
-    description?: string;
-    internalNumber?: string;
+import { IProduct } from "./product.model.js";
+import { IEntity } from "@loomcore/common/models";
+export interface IProductWithCategory extends IProduct, IEntity {
     category: ICategory;
 }
-export declare const ProductWithCategorySchema: import("@sinclair/typebox").TObject<{
+export declare const ProductWithCategorySchema: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TString;
     description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     internalNumber: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    categoryId: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
+}>, import("@sinclair/typebox").TObject<{
     category: import("@sinclair/typebox").TSchema;
-}>;
-export declare const ProductWithCategorySpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
-export declare const PublicProductWithCategorySchema: import("@sinclair/typebox").TObject<{
-    name: import("@sinclair/typebox").TString;
-    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>]>;
+export declare const ProductWithCategoryPublicSchema: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{}>, import("@sinclair/typebox").TObject<{
     category: import("@sinclair/typebox").TSchema;
-}>;
+}>]>;
+export declare const ProductWithCategorySpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
 export declare const ProductWithCategoryPublicSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/__tests__/models/product-with-category.model.js

@@ -1,12 +1,18 @@
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
 import { CategorySpec } from "./category.model.js";
-export const ProductWithCategorySchema = Type.Object({
-    name: Type.String(),
-    description: Type.Optional(Type.String()),
-    internalNumber: Type.Optional(Type.String()),
-    category: CategorySpec.fullSchema,
-});
-export const ProductWithCategorySpec = entityUtils.getModelSpec(ProductWithCategorySchema, { isAuditable: true });
-export const PublicProductWithCategorySchema = Type.Omit(ProductWithCategorySchema, ['internalNumber']);
-export const ProductWithCategoryPublicSpec = entityUtils.getModelSpec(PublicProductWithCategorySchema);
+import { ProductPublicSchema, ProductSchema } from "./product.model.js";
+export const ProductWithCategorySchema = Type.Intersect([
+    ProductSchema,
+    Type.Object({
+        category: CategorySpec.fullSchema,
+    })
+]);
+export const ProductWithCategoryPublicSchema = Type.Intersect([
+    ProductPublicSchema,
+    Type.Object({
+        category: CategorySpec.fullSchema,
+    })
+]);
+export const ProductWithCategorySpec = entityUtils.getModelSpec(ProductWithCategorySchema);
+export const ProductWithCategoryPublicSpec = entityUtils.getModelSpec(ProductWithCategoryPublicSchema);

package/dist/__tests__/models/product.model.d.ts

@@ -13,4 +13,4 @@ export declare const ProductSchema: import("@sinclair/typebox").TObject<{
     categoryId: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
 }>;
 export declare const ProductSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
-export declare const PublicProductSchema: import("@sinclair/typebox").TObject<{}>;
+export declare const ProductPublicSchema: import("@sinclair/typebox").TObject<{}>;

package/dist/__tests__/models/product.model.js

@@ -7,4 +7,4 @@ export const ProductSchema = Type.Object({
     categoryId: Type.Union([Type.String({ title: 'Category ID' }), Type.Number({ title: 'Category ID' })]),
 });
 export const ProductSpec = entityUtils.getModelSpec(ProductSchema, { isAuditable: true });
-export const PublicProductSchema = Type.Omit(ProductSpec.fullSchema, ['internalNumber']);
+export const ProductPublicSchema = Type.Omit(ProductSpec.fullSchema, ['internalNumber']);

package/dist/__tests__/postgres.test-database.js

@@ -53,7 +53,6 @@ export class TestPostgresDatabase {
                     connectionString,
                     connectionTimeoutMillis: 5000,
                 });
-                this.postgresPool = pool;
             }
             else {
                 const { Client } = newDb().adapters.createPg();
@@ -61,8 +60,8 @@ export class TestPostgresDatabase {
                 await postgresClient.connect();
                 pool = postgresClient;
             }
-            const testDatabase = new PostgresDatabase(postgresClient);
-            this.database = testDatabase;
+            this.postgresPool = pool;
+            this.database = new PostgresDatabase(postgresClient);
             this.postgresClient = postgresClient;
             const { initializeSystemUserContext, isSystemUserContextInitialized } = await import('@loomcore/common/models');
             if (!isSystemUserContextInitialized()) {
@@ -70,7 +69,7 @@ export class TestPostgresDatabase {
             }
             await runInitialSchemaMigrations(pool, config);
             await runTestSchemaMigrations(pool, config);
-            testUtils.initialize(testDatabase);
+            testUtils.initialize(this.database);
             await this.createIndexes(postgresClient);
             await testUtils.createMetaOrg();
         }
@@ -97,9 +96,14 @@ export class TestPostgresDatabase {
       WHERE "table_schema" = 'public'
       AND "table_type" = 'BASE TABLE'
     `);
-        result.rows.forEach(async (row) => {
-            await this.postgresClient?.query(`TRUNCATE TABLE "${row.table_name}" RESTART IDENTITY CASCADE`);
-        });
+        if (USE_REAL_POSTGRES) {
+            await this.postgresClient?.query(`TRUNCATE TABLE ${result.rows.map(row => `"${row.table_name}"`).join(', ')} RESTART IDENTITY CASCADE`);
+        }
+        else {
+            result.rows.forEach(async (row) => {
+                await this.postgresClient?.query(`TRUNCATE TABLE "${row.table_name}" RESTART IDENTITY CASCADE`);
+            });
+        }
     }
     async cleanup() {
         if (this.database) {

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

@@ -1,22 +1,20 @@
 import { LeftJoin } from "../../operations/left-join.operation.js";
 import { InnerJoin } from "../../operations/inner-join.operation.js";
 import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
-import { toSnakeCase } from "./convert-keys.util.js";
-function convertFieldToSnakeCase(field) {
-    if (field.startsWith("_")) {
-        return field;
-    }
-    return toSnakeCase(field);
-}
 export function buildJoinClauses(operations, mainTableName) {
     const joinClauses = [];
     for (const operation of operations) {
         if (operation instanceof LeftJoin || operation instanceof InnerJoin || operation instanceof LeftJoinMany) {
             const joinType = operation instanceof InnerJoin ? "INNER JOIN" : "LEFT JOIN";
-            const localColumn = convertFieldToSnakeCase(operation.localField);
-            const foreignColumn = convertFieldToSnakeCase(operation.foreignField);
-            const leftSide = mainTableName ? `"${mainTableName}"."${localColumn}"` : `"${localColumn}"`;
-            joinClauses.push(`${joinType} "${operation.from}" AS "${operation.as}" ON ${leftSide} = ${operation.as}."${foreignColumn}"`);
+            let leftSide;
+            if (operation.localField.includes(".")) {
+                const [alias, column] = operation.localField.split(".");
+                leftSide = `"${alias}"."${column}"`;
+            }
+            else {
+                leftSide = mainTableName ? `"${mainTableName}"."${operation.localField}"` : `"${operation.localField}"`;
+            }
+            joinClauses.push(`${joinType} "${operation.from}" AS "${operation.as}" ON ${leftSide} = "${operation.as}"."${operation.foreignField}"`);
         }
     }
     return joinClauses.join(' ');

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

@@ -1,7 +1,6 @@
 import { LeftJoin } from '../../operations/left-join.operation.js';
 import { InnerJoin } from '../../operations/inner-join.operation.js';
 import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
-import { buildAs } from './build-things.util.js';
 async function getTableColumns(client, tableName) {
     const result = await client.query(`
             SELECT column_name
@@ -12,17 +11,6 @@ async function getTableColumns(client, tableName) {
         `, [tableName]);
     return result.rows.map(row => row.column_name);
 }
-function findEnrichmentTarget(operation, operations) {
-    if (!operation.localField.includes('.')) {
-        return null;
-    }
-    const [alias] = operation.localField.split('.');
-    const target = operations.find(op => op instanceof LeftJoinMany && op.as === alias);
-    if (target && operations.indexOf(target) < operations.indexOf(operation)) {
-        return { target, field: operation.localField.split('.')[1] };
-    }
-    return null;
-}
 export async function buildSelectClause(client, mainTableName, operations) {
     const leftJoinOperations = operations.filter(op => op instanceof LeftJoin);
     const innerJoinOperations = operations.filter(op => op instanceof InnerJoin);
@@ -33,7 +21,7 @@ export async function buildSelectClause(client, mainTableName, operations) {
     for (const join of [...leftJoinOperations, ...innerJoinOperations, ...leftJoinManyOperations]) {
         const joinColumns = await getTableColumns(client, join.from);
         for (const col of joinColumns) {
-            joinSelects.push(`${join.as}."${col}" AS "${buildAs(col, join)}"`);
+            joinSelects.push(`"${join.as}"."${col}" AS "${join.as}__${col}"`);
         }
     }
     const allSelects = [...mainSelects, ...joinSelects];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.116",
+  "version": "0.1.118",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -19,7 +19,8 @@
     "typecheck": "tsc",
     "test": "npm-run-all -s test:postgres test:mongodb",
     "test:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run",
-    "test:postgres:real": "cross-env NODE_ENV=test TEST_DATABASE=postgres USE_REAL_POSTGRES=true vitest run",
+    "test:postgres:real-test": "cross-env NODE_ENV=test TEST_DATABASE=postgres USE_REAL_POSTGRES=true vitest run",
+    "test:postgres:real": "npm-run-all -s test:db:start test:postgres:real-test test:db:stop",
     "test:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run",
     "test:ci": "npm-run-all -s test:ci:postgres test:ci:mongodb",
     "test:ci:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run --reporter=json --outputFile=test-results-postgres.json",

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

@@ -1,2 +0,0 @@
-import { Operation } from "../../operations/index.js";
-export declare function buildAs(columnName: string, operation: Operation): string;

package/dist/databases/postgres/utils/build-things.util.js

@@ -1,3 +0,0 @@
-export function buildAs(columnName, operation) {
-    return `${operation.as}__${columnName}`;
-}