@rytass/wms-module-graphql 0.6.0 → 0.6.1

package/index.cjs.js

@@ -55,6 +55,65 @@ exports.LoaderService = class LoaderService {
         const fields = ___default.default(Object.keys(__from)).sort();
         return `${__hash}_${fields.map((field) => data[field]).join('_')}`;
     }
+    /**
+     * resolve a `__from` property name to the physical column it is stored in.
+     *
+     * TypeORM's `FindOptionsWhere` only accepts real column properties. A
+     * `@RelationId()` property — e.g. `LocationEntityClass.parentId`, which mirrors
+     * the `parent` tree relation — is virtual and is rejected with
+     * `EntityPropertyNotFoundError`, even though it is backed by the relation's
+     * join column. Map those back to their join column so they stay batchable.
+     * @param EntityMetadata
+     * @param string
+     * @returns string | null
+     */
+    resolveColumnName(metadata, propertyName) {
+        const column = metadata.findColumnWithPropertyName(propertyName);
+        if (column)
+            return column.databaseName;
+        const relationId = metadata.relationIds.find((candidate) => candidate.propertyName === propertyName);
+        const joinColumns = relationId?.relation.joinColumns ?? [];
+        return joinColumns.length === 1 ? joinColumns[0].databaseName : null;
+    }
+    /**
+     * build the where clause for `__from` keys that TypeORM's find options cannot
+     * express (see {@link resolveColumnName}), by addressing the columns directly.
+     * @param SelectQueryBuilder
+     * @param EntityMetadata
+     * @param LoaderOptions[]
+     * @param (keyof T)[]
+     */
+    applyColumnWhere(qb, metadata, options, primaryKeys) {
+        const columns = primaryKeys.map((primaryKey) => {
+            const columnName = this.resolveColumnName(metadata, String(primaryKey));
+            if (!columnName)
+                throw new Error(`Loader cannot resolve property "${String(primaryKey)}" to a column of "${metadata.name}".`);
+            return {
+                primaryKey,
+                column: `entity.${this.dataSource.driver.escape(columnName)}`,
+            };
+        });
+        if (columns.length === 1) {
+            const [{ primaryKey, column }] = columns;
+            qb.andWhere(`${column} IN (:...wmsLoaderValues)`, {
+                wmsLoaderValues: options.map(({ __from }) => __from[primaryKey]),
+            });
+            return;
+        }
+        qb.andWhere(new typeorm.Brackets((where) => {
+            options.forEach(({ __from }, optionIndex) => {
+                const parameters = {};
+                const predicate = columns
+                    .map(({ primaryKey, column }, columnIndex) => {
+                    const parameter = `wmsLoaderValue_${optionIndex}_${columnIndex}`;
+                    parameters[parameter] = __from[primaryKey];
+                    return `${column} = :${parameter}`;
+                })
+                    .join(' AND ');
+                where.orWhere(`(${predicate})`, parameters);
+            });
+        }));
+    }
     /**
      * query data by collecting primary keys from options with same `__entity`
      * @param LoaderOptions[]
@@ -65,7 +124,10 @@ exports.LoaderService = class LoaderService {
         const repo = this.dataSource.getRepository(__entity);
         let qb = repo.createQueryBuilder('entity');
         const primaryKeys = Object.keys(__from);
-        if (primaryKeys.length > 1)
+        const hasVirtualKey = primaryKeys.some((primaryKey) => !repo.metadata.findColumnWithPropertyName(String(primaryKey)));
+        if (hasVirtualKey)
+            this.applyColumnWhere(qb, repo.metadata, options, primaryKeys);
+        else if (primaryKeys.length > 1)
             qb.setFindOptions({ where: options.map(({ __from }) => __from) });
         else {
             const [primaryKey] = primaryKeys;
@@ -3611,8 +3673,21 @@ let LocationResolver = class LocationResolver {
             __from: { id: parentId },
         });
     }
-    children({ children }) {
-        return children;
+    /**
+     * `children` must never be read off the parent entity: only
+     * `LocationQuery.location` and `LocationService.findMany` eager-load the tree
+     * relation. Every other producer of a `LocationDto` (stock/loader/change-log/
+     * transfer/ship/receive/warehouse-map resolvers, the `parent` field above and
+     * the create/update mutations) hands back an entity whose `children` is
+     * `undefined`, which breaks the non-nullable list. Always resolve through the
+     * request-scoped loader instead.
+     */
+    children({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: wmsModuleCore.LocationEntityClass,
+            __from: { parentId: id },
+            __conditions: (qb) => qb.orderBy('entity."key"', 'ASC'),
+        });
     }
 };
 tslib.__decorate([
@@ -3634,9 +3709,10 @@ tslib.__decorate([
 tslib.__decorate([
     graphql.ResolveField(() => [LocationDto]),
     tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
     tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.LocationEntityClass]),
-    tslib.__metadata("design:returntype", void 0)
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.LocationEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
 ], LocationResolver.prototype, "children", null);
 LocationResolver = tslib.__decorate([
     graphql.Resolver(() => LocationDto)

package/lib/helpers/loader.service.d.ts

@@ -33,6 +33,28 @@ export declare class LoaderService {
      * @returns Map<string, data>
      */
     private useIndex;
+    /**
+     * resolve a `__from` property name to the physical column it is stored in.
+     *
+     * TypeORM's `FindOptionsWhere` only accepts real column properties. A
+     * `@RelationId()` property — e.g. `LocationEntityClass.parentId`, which mirrors
+     * the `parent` tree relation — is virtual and is rejected with
+     * `EntityPropertyNotFoundError`, even though it is backed by the relation's
+     * join column. Map those back to their join column so they stay batchable.
+     * @param EntityMetadata
+     * @param string
+     * @returns string | null
+     */
+    private resolveColumnName;
+    /**
+     * build the where clause for `__from` keys that TypeORM's find options cannot
+     * express (see {@link resolveColumnName}), by addressing the columns directly.
+     * @param SelectQueryBuilder
+     * @param EntityMetadata
+     * @param LoaderOptions[]
+     * @param (keyof T)[]
+     */
+    private applyColumnWhere;
     /**
      * query data by collecting primary keys from options with same `__entity`
      * @param LoaderOptions[]

package/lib/helpers/loader.service.js

@@ -3,7 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { createHash } from 'crypto';
 import _ from 'lodash';
 import { LRUCache } from 'lru-cache';
-import { DataSource, In } from 'typeorm';
+import { DataSource, Brackets, In } from 'typeorm';
 import DataLoader from 'dataloader';
 
 let LoaderService = class LoaderService {
@@ -42,6 +42,65 @@ let LoaderService = class LoaderService {
         const fields = _(Object.keys(__from)).sort();
         return `${__hash}_${fields.map((field) => data[field]).join('_')}`;
     }
+    /**
+     * resolve a `__from` property name to the physical column it is stored in.
+     *
+     * TypeORM's `FindOptionsWhere` only accepts real column properties. A
+     * `@RelationId()` property — e.g. `LocationEntityClass.parentId`, which mirrors
+     * the `parent` tree relation — is virtual and is rejected with
+     * `EntityPropertyNotFoundError`, even though it is backed by the relation's
+     * join column. Map those back to their join column so they stay batchable.
+     * @param EntityMetadata
+     * @param string
+     * @returns string | null
+     */
+    resolveColumnName(metadata, propertyName) {
+        const column = metadata.findColumnWithPropertyName(propertyName);
+        if (column)
+            return column.databaseName;
+        const relationId = metadata.relationIds.find((candidate) => candidate.propertyName === propertyName);
+        const joinColumns = relationId?.relation.joinColumns ?? [];
+        return joinColumns.length === 1 ? joinColumns[0].databaseName : null;
+    }
+    /**
+     * build the where clause for `__from` keys that TypeORM's find options cannot
+     * express (see {@link resolveColumnName}), by addressing the columns directly.
+     * @param SelectQueryBuilder
+     * @param EntityMetadata
+     * @param LoaderOptions[]
+     * @param (keyof T)[]
+     */
+    applyColumnWhere(qb, metadata, options, primaryKeys) {
+        const columns = primaryKeys.map((primaryKey) => {
+            const columnName = this.resolveColumnName(metadata, String(primaryKey));
+            if (!columnName)
+                throw new Error(`Loader cannot resolve property "${String(primaryKey)}" to a column of "${metadata.name}".`);
+            return {
+                primaryKey,
+                column: `entity.${this.dataSource.driver.escape(columnName)}`,
+            };
+        });
+        if (columns.length === 1) {
+            const [{ primaryKey, column }] = columns;
+            qb.andWhere(`${column} IN (:...wmsLoaderValues)`, {
+                wmsLoaderValues: options.map(({ __from }) => __from[primaryKey]),
+            });
+            return;
+        }
+        qb.andWhere(new Brackets((where) => {
+            options.forEach(({ __from }, optionIndex) => {
+                const parameters = {};
+                const predicate = columns
+                    .map(({ primaryKey, column }, columnIndex) => {
+                    const parameter = `wmsLoaderValue_${optionIndex}_${columnIndex}`;
+                    parameters[parameter] = __from[primaryKey];
+                    return `${column} = :${parameter}`;
+                })
+                    .join(' AND ');
+                where.orWhere(`(${predicate})`, parameters);
+            });
+        }));
+    }
     /**
      * query data by collecting primary keys from options with same `__entity`
      * @param LoaderOptions[]
@@ -52,7 +111,10 @@ let LoaderService = class LoaderService {
         const repo = this.dataSource.getRepository(__entity);
         let qb = repo.createQueryBuilder('entity');
         const primaryKeys = Object.keys(__from);
-        if (primaryKeys.length > 1)
+        const hasVirtualKey = primaryKeys.some((primaryKey) => !repo.metadata.findColumnWithPropertyName(String(primaryKey)));
+        if (hasVirtualKey)
+            this.applyColumnWhere(qb, repo.metadata, options, primaryKeys);
+        else if (primaryKeys.length > 1)
             qb.setFindOptions({ where: options.map(({ __from }) => __from) });
         else {
             const [primaryKey] = primaryKeys;

package/lib/resolvers/location.resolver.d.ts

@@ -6,5 +6,14 @@ import { LocationEntityClass } from '@rytass/wms-module-core';
 export declare class LocationResolver {
     mapData({ id }: LocationDto, { loaders }: LoaderType<WarehouseMapEntity>): Promise<MapDataDto | null>;
     parent({ parentId }: LocationEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationEntityClass> | null;
-    children({ children }: LocationEntityClass): import("@rytass/wms-base-nestjs-module").LocationEntity[];
+    /**
+     * `children` must never be read off the parent entity: only
+     * `LocationQuery.location` and `LocationService.findMany` eager-load the tree
+     * relation. Every other producer of a `LocationDto` (stock/loader/change-log/
+     * transfer/ship/receive/warehouse-map resolvers, the `parent` field above and
+     * the create/update mutations) hands back an entity whose `children` is
+     * `undefined`, which breaks the non-nullable list. Always resolve through the
+     * request-scoped loader instead.
+     */
+    children({ id }: LocationEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto[]>;
 }

package/lib/resolvers/location.resolver.js

@@ -21,8 +21,21 @@ let LocationResolver = class LocationResolver {
             __from: { id: parentId },
         });
     }
-    children({ children }) {
-        return children;
+    /**
+     * `children` must never be read off the parent entity: only
+     * `LocationQuery.location` and `LocationService.findMany` eager-load the tree
+     * relation. Every other producer of a `LocationDto` (stock/loader/change-log/
+     * transfer/ship/receive/warehouse-map resolvers, the `parent` field above and
+     * the create/update mutations) hands back an entity whose `children` is
+     * `undefined`, which breaks the non-nullable list. Always resolve through the
+     * request-scoped loader instead.
+     */
+    children({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: LocationEntityClass,
+            __from: { parentId: id },
+            __conditions: (qb) => qb.orderBy('entity."key"', 'ASC'),
+        });
     }
 };
 __decorate([
@@ -44,9 +57,10 @@ __decorate([
 __decorate([
     ResolveField(() => [LocationDto]),
     __param(0, Parent()),
+    __param(1, Context()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [LocationEntityClass]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:paramtypes", [LocationEntityClass, Object]),
+    __metadata("design:returntype", Promise)
 ], LocationResolver.prototype, "children", null);
 LocationResolver = __decorate([
     Resolver(() => LocationDto)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rytass/wms-module-graphql",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Rytass WMS Module — GraphQL schema, resolvers and DTOs for warehouse management",
   "keywords": [
     "rytass",
@@ -57,7 +57,7 @@
     "@nestjs/apollo": ">=13.0.0 <13.2.0",
     "@nestjs/common": "^11.0.0",
     "@nestjs/graphql": "^13.0.0",
-    "@rytass/wms-module-core": "^0.3.0",
+    "@rytass/wms-module-core": "^0.3.1",
     "graphql": "^16.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
     "rxjs": "^7.8.0",