@snowtop/ent 0.2.12 → 0.2.14

package/action/orchestrator.d.ts

@@ -17,7 +17,7 @@ export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends D
     action?: Action<TEnt, Builder<TEnt, TViewer>, TViewer, TInput>;
     schema: SchemaInputType;
     editedFields(): Map<string, any> | Promise<Map<string, any>>;
-    updateInput?: (data: TInput) => void;
+    updateInput?: (data: TInput, operation?: WriteOperation) => void;
     expressions?: Map<string, clause.Clause>;
     fieldInfo: FieldInfoMap;
 }
@@ -38,6 +38,8 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private options;
     private edgeSet;
     private edges;
+    private fieldEdgeSources;
+    private fieldEdgeInputs;
     private conditionalEdges;
     private validatedFields;
     private logValues;
@@ -59,6 +61,9 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     setDisableTransformations(val: boolean): void;
     setOnConflictOptions(onConflict: CreateRowOptions["onConflict"]): void;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
+    __setFieldEdges<T2 extends Ent>(fieldName: string, ids: readonly (ID | Builder<T2, any>)[] | undefined, edgeType: string, nodeType: string, stored: {
+        existingIDs?: readonly ID[];
+    }): void;
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeInboundEdge(id1: ID, edgeType: string, options?: AssocEdgeOptions): void;
     removeOutboundEdge(id2: ID, edgeType: string, options?: AssocEdgeOptions): void;

package/action/orchestrator.js

@@ -39,12 +39,25 @@ const schema_1 = require("../schema/schema");
 const operations_1 = require("./operations");
 const action_1 = require("../action");
 const privacy_1 = require("../core/privacy");
+const privacy_2 = require("./privacy");
 const executor_1 = require("./executor");
 const memoize_1 = require("../core/memoize");
 const logger_1 = require("../core/logger");
 const clause = __importStar(require("../core/clause"));
 const types_1 = require("util/types");
 const operations_2 = require("./operations");
+function invalidFieldError(fieldName, value) {
+    let description;
+    try {
+        description = `${value}`;
+    }
+    catch {
+        // Null-prototype records (and lists containing them) cannot be coerced
+        // to strings. Diagnostic formatting must not hide a validation failure.
+        description = "[unprintable value]";
+    }
+    return new Error(`invalid field ${fieldName} with value ${description}`);
+}
 var edgeDirection;
 (function (edgeDirection) {
     edgeDirection[edgeDirection["inboundEdge"] = 0] = "inboundEdge";
@@ -99,6 +112,8 @@ class Orchestrator {
         this.options = options;
         this.edgeSet = new Set();
         this.edges = new Map();
+        this.fieldEdgeSources = new WeakMap();
+        this.fieldEdgeInputs = new Map();
         this.conditionalEdges = new Map();
         this.validatedFields = null;
         this.changesets = [];
@@ -155,6 +170,105 @@ class Orchestrator {
             direction: edgeDirection.inboundEdge,
         }), action_1.WriteOperation.Insert, options?.conditional);
     }
+    // Update inverse edges for generated fields while preserving explicit edge
+    // operations. This method is internal. For edits and deletions, use stored IDs.
+    // If `stored` omits `existingIDs`, reuse the IDs captured before synchronous
+    // default updates.
+    __setFieldEdges(fieldName, ids, edgeType, nodeType, stored) {
+        // Existing builders and literal IDs can refer to the same database row.
+        // Use placeholder IDs as queue keys so unsaved builders remain dependencies.
+        const endpointID = (id) => (0, privacy_2.isBuilder)(id) ? (id.existingEnt?.id ?? id.placeholderID) : id;
+        this.fieldEdgeInputs.set(fieldName, {
+            edgeType,
+            nodeType,
+            ids,
+            existingIDs: stored.existingIDs ??
+                this.fieldEdgeInputs.get(fieldName)?.existingIDs ??
+                [],
+        });
+        const inserts = new Map();
+        const removals = new Map();
+        const retained = new Set();
+        const contribute = (map, id, source) => {
+            const key = (0, privacy_2.isBuilder)(id) ? id.placeholderID : id;
+            let entry = map.get(key);
+            if (!entry) {
+                map.set(key, (entry = { id, sources: new Set() }));
+            }
+            entry.sources.add(source);
+        };
+        for (const [source, field] of this.fieldEdgeInputs) {
+            if (field.edgeType !== edgeType) {
+                continue;
+            }
+            const existing = this.actualOperation === action_1.WriteOperation.Insert ? [] : field.existingIDs;
+            const current = this.actualOperation === action_1.WriteOperation.Delete ? [] : field.ids;
+            for (const id of current ?? existing) {
+                retained.add(endpointID(id));
+            }
+            if (current !== undefined) {
+                for (const id of current) {
+                    contribute(inserts, id, source);
+                }
+                for (const id of existing) {
+                    contribute(removals, id, source);
+                }
+            }
+        }
+        const manualEndpoints = (op) => {
+            const endpoints = new Set();
+            for (const edge of this.edges.get(edgeType)?.get(op)?.values() ?? []) {
+                if (!this.fieldEdgeSources.has(edge)) {
+                    endpoints.add(endpointID(edge.id));
+                }
+            }
+            return endpoints;
+        };
+        const manualInserts = manualEndpoints(action_1.WriteOperation.Insert);
+        const manualRemovals = manualEndpoints(action_1.WriteOperation.Delete);
+        for (const id of removals.keys()) {
+            if (retained.has(id) || manualInserts.has(id)) {
+                removals.delete(id);
+            }
+        }
+        for (const [key, contribution] of inserts) {
+            const id = endpointID(contribution.id);
+            if (manualInserts.has(id) || manualRemovals.has(id)) {
+                inserts.delete(key);
+            }
+        }
+        for (const [op, desired] of [
+            [action_1.WriteOperation.Insert, inserts],
+            [action_1.WriteOperation.Delete, removals],
+        ]) {
+            const queued = this.edges.get(edgeType)?.get(op);
+            for (const [id, edge] of queued ?? []) {
+                if (!this.fieldEdgeSources.has(edge)) {
+                    continue;
+                }
+                const contribution = desired.get(id);
+                if (contribution) {
+                    this.fieldEdgeSources.set(edge, contribution.sources);
+                }
+                else {
+                    queued.delete(id);
+                }
+            }
+            for (const [key, contribution] of desired) {
+                if (this.edges.get(edgeType)?.get(op)?.has(key)) {
+                    continue;
+                }
+                const edge = new edgeInputData({
+                    id: contribution.id,
+                    edgeType,
+                    nodeType,
+                    direction: edgeDirection.inboundEdge,
+                });
+                this.fieldEdgeSources.set(edge, contribution.sources);
+                this.addEdge(edge, op);
+            }
+        }
+    }
     addOutboundEdge(id2, edgeType, nodeType, options) {
         this.addEdge(new edgeInputData({
             id: id2,
@@ -532,27 +646,22 @@ class Orchestrator {
     }
     async triggers(action, builder, triggers) {
         const groups = [];
-        let lastArray = 0;
-        let prevWasArray = false;
-        for (let i = 0; i < triggers.length; i++) {
-            let t = triggers[i];
-            if (Array.isArray(t)) {
-                if (!prevWasArray) {
-                    // @ts-ignore
-                    groups.push(triggers.slice(lastArray, i));
+        let group = [];
+        for (const trigger of triggers) {
+            if (Array.isArray(trigger)) {
+                if (group.length) {
+                    groups.push(group);
+                    group = [];
                 }
-                groups.push(t);
-                prevWasArray = true;
-                lastArray++;
+                groups.push(trigger);
             }
             else {
-                if (i === triggers.length - 1) {
-                    // @ts-ignore
-                    groups.push(triggers.slice(lastArray, i + 1));
-                }
-                prevWasArray = false;
+                group.push(trigger);
             }
         }
+        if (group.length) {
+            groups.push(group);
+        }
         for (const triggers of groups) {
             await Promise.all(triggers.map(async (trigger) => {
                 let ret = await trigger.changeset(builder, action.getInput());
@@ -606,6 +715,8 @@ class Orchestrator {
         // if disable transformations set, don't do schema transform and just do the right thing
         // else apply schema tranformation if it exists
         let transformed = null;
+        const initialOperation = this.actualOperation;
+        const initialEnt = this.existingEnt;
         const sqlOp = this.getSQLStatementOperation();
         // why is transform write technically different from upsert?
         // it's create -> update just at the db level...
@@ -668,6 +779,13 @@ class Orchestrator {
                 builder.existingEnt = transformed.existingEnt;
             }
         }
+        if (this.fieldEdgeInputs.size > 0 &&
+            (initialOperation !== this.actualOperation ||
+                initialEnt !== this.existingEnt)) {
+            // Refresh inverse edges for the transformed operation and row before
+            // applying defaults or running triggers.
+            editedFields = await this.options.editedFields();
+        }
         // transforming before doing default fields so that we don't create a new id
         // and anything that depends on the type of operations knows what it is
         const userDefinedKeys = new Set();
@@ -728,7 +846,7 @@ class Orchestrator {
             };
             if (updateInput && this.options.updateInput) {
                 // this basically fixes #605. just needs to be exposed correctly
-                this.options.updateInput(this.defaultFieldsByTSName);
+                this.options.updateInput(this.defaultFieldsByTSName, this.actualOperation);
             }
         }
         return { data, userDefinedKeys };
@@ -764,7 +882,7 @@ class Orchestrator {
                     valid = await valid;
                 }
                 if (!valid) {
-                    return new Error(`invalid field ${fieldName} with value ${value}`);
+                    return invalidFieldError(fieldName, value);
                 }
             }
             // keep track of dependencies to resolve
@@ -779,7 +897,7 @@ class Orchestrator {
                     valid = await valid;
                 }
                 if (!valid) {
-                    return new Error(`invalid field ${fieldName} with value ${value}`);
+                    return invalidFieldError(fieldName, value);
                 }
             }
             if (field.format) {
@@ -855,6 +973,20 @@ class Orchestrator {
                 }
             }
         }
+        // If a trigger clears an input, the SQL write can still use its computed
+        // default. Update inverse edges for defaults included in `data`; apply edit
+        // defaults only when the edit has data to save.
+        for (const [fieldName, field] of this.fieldEdgeInputs) {
+            if (field.ids !== undefined ||
+                data[this.getStorageKey(fieldName)] === undefined) {
+                continue;
+            }
+            const value = this.defaultFieldsByFieldName[fieldName];
+            if (value === undefined) {
+                continue;
+            }
+            this.__setFieldEdges(fieldName, value === null ? [] : Array.isArray(value) ? value : [value], field.edgeType, field.nodeType, {});
+        }
         this.validatedFields = data;
         this.logValues = logValues;
         return errors;

package/action/privacy.d.ts

@@ -1,5 +1,6 @@
 import { Builder } from "./action";
 import { Viewer, ID, Ent, PrivacyResult, PrivacyPolicyRule } from "../core/base";
+export declare function isBuilder(node: ID | Builder<Ent, any>): node is Builder<Ent, any>;
 export declare class DenyIfBuilder implements PrivacyPolicyRule {
     private id?;
     constructor(id?: (ID | Builder<Ent, any>) | undefined);

package/action/privacy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AllowIfBuilder = exports.DenyIfBuilder = void 0;
+exports.isBuilder = isBuilder;
 const base_1 = require("../core/base");
 function isBuilder(node) {
     return node.placeholderID !== undefined;

package/core/clause.js

@@ -185,7 +185,7 @@ class queryClause {
         this.prefix = prefix;
     }
     clause(idx, alias) {
-        const q = (0, query_impl_1.buildQuery)(this.dependentQueryOptions);
+        const q = (0, query_impl_1.buildQuery)(this.dependentQueryOptions, idx);
         return `${this.prefix} (${q})`;
     }
     columns() {

package/core/query_impl.d.ts

@@ -28,6 +28,6 @@ export declare function reverseOrderBy(orderby: OrderBy): OrderBy;
 interface JoinInfo extends QueryFragmentInfo {
 }
 export declare function getJoinInfo(join: NonNullable<QueryableDataOptions["join"]>, clauseIdx?: number): JoinInfo;
-export declare function buildQueryData(options: QueryableDataOptions): BuiltQueryData;
-export declare function buildQuery(options: QueryableDataOptions): string;
+export declare function buildQueryData(options: QueryableDataOptions, startIdx?: number): BuiltQueryData;
+export declare function buildQuery(options: QueryableDataOptions, startIdx?: number): string;
 export {};

package/core/query_impl.js

@@ -171,12 +171,14 @@ function getJoinInfo(join, clauseIdx = 1) {
         logValues,
     };
 }
-function buildQueryData(options) {
+// startIdx is the first placeholder number when embedding this query in another.
+// The returned values contain only this query's parameters.
+function buildQueryData(options, startIdx = 1) {
     const fieldsAlias = options.fieldsAlias ?? options.alias;
-    const fieldInfo = getFieldsInfo(options.fields, fieldsAlias, options.disableFieldsAlias, 1);
+    const fieldInfo = getFieldsInfo(options.fields, fieldsAlias, options.disableFieldsAlias, startIdx);
     const values = [...fieldInfo.values];
     const logValues = [...fieldInfo.logValues];
-    let clauseIdx = 1 + fieldInfo.valuesUsed;
+    let clauseIdx = startIdx + fieldInfo.valuesUsed;
     const parts = [];
     const tableName = options.alias
         ? `${options.tableName} AS ${options.alias}`
@@ -220,6 +222,6 @@ function buildQueryData(options) {
         logValues,
     };
 }
-function buildQuery(options) {
-    return buildQueryData(options).query;
+function buildQuery(options, startIdx = 1) {
+    return buildQueryData(options, startIdx).query;
 }

package/graphql/graphql.js

@@ -631,11 +631,13 @@ exports.gqlQuery = GQLCapture.gqlQuery;
 exports.gqlMutation = GQLCapture.gqlMutation;
 exports.gqlContextType = GQLCapture.gqlContextType;
 exports.gqlConnection = GQLCapture.gqlConnection;
-// this requires the developer to npm-install "graphql-upload on their own"
+// Apps that use uploads must install graphql-upload on their own. Keep the
+// runtime import behind @snowtop/ent/graphql/upload so normal GraphQL users do
+// not load the optional peer dependency.
 const gqlFileUpload = {
     type: "GraphQLUpload",
-    importPath: "graphql-upload",
+    importPath: "@snowtop/ent/graphql/upload",
     tsType: "FileUpload",
-    tsImportPath: "graphql-upload",
+    tsImportPath: "@snowtop/ent/graphql/upload",
 };
 exports.gqlFileUpload = gqlFileUpload;

package/graphql/upload.d.ts

@@ -0,0 +1,16 @@
+import type { Readable } from "stream";
+import type { GraphQLScalarType } from "graphql";
+export interface FileUpload {
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    createReadStream(): Readable;
+}
+export interface GraphQLUploadExpressOptions {
+    maxFieldSize?: number;
+    maxFileSize?: number;
+    maxFiles?: number;
+    [key: string]: unknown;
+}
+export declare const GraphQLUpload: GraphQLScalarType;
+export declare const graphqlUploadExpress: (options?: GraphQLUploadExpressOptions) => any;

package/graphql/upload.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlUploadExpress = exports.GraphQLUpload = void 0;
+const GraphQLUploadImport = require("graphql-upload/GraphQLUpload.js");
+const graphqlUploadExpressImport = require("graphql-upload/graphqlUploadExpress.js");
+exports.GraphQLUpload = GraphQLUploadImport;
+exports.graphqlUploadExpress = graphqlUploadExpressImport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -18,14 +18,18 @@
     "tsconfig-paths": "4.2.0",
     "tslib": "2.8.1",
     "typescript": "5.9.3",
-    "uuid": "9.0.1"
+    "uuid": "11.1.1"
   },
   "peerDependencies": {
     "@swc-node/register": "1.6.8",
     "better-sqlite3": "12.5.0",
-    "graphql": "16.12.0"
+    "graphql": "16.12.0",
+    "graphql-upload": "15.0.2"
   },
   "peerDependenciesMeta": {
+    "graphql-upload": {
+      "optional": true
+    },
     "better-sqlite3": {
       "optional": true
     },

package/schema/struct_field.js

@@ -35,7 +35,7 @@ class StructField extends field_1.BaseField {
         }
     }
     formatImpl(obj, nested) {
-        if (!(obj instanceof Object)) {
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
             throw new Error("valid was not called");
         }
         let ret = {};
@@ -122,7 +122,12 @@ class StructField extends field_1.BaseField {
         return this.formatImpl(obj, nested);
     }
     async validImpl(obj) {
-        if (!(obj instanceof Object)) {
+        // GraphQL.js valueFromAST turns inline objects such as prefs: {enabled: true}
+        // into null-prototype records, which fail instanceof Object. Objects supplied
+        // in the JSON variables payload use ordinary prototypes instead. A struct
+        // can still be inline when other values use variables; object-valued variable
+        // defaults also go through valueFromAST when the variable is omitted.
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
             return false;
         }
         let promises = [];
@@ -241,9 +246,6 @@ class StructField extends field_1.BaseField {
             }));
             return valid.every((b) => b);
         }
-        if (!(obj instanceof Object)) {
-            return false;
-        }
         return this.validImpl(obj);
     }
 }

package/schema/union_field.js

@@ -25,7 +25,7 @@ class UnionField extends field_1.BaseField {
         }
     }
     format(obj) {
-        if (!(obj instanceof Object)) {
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
             throw new Error("valid was not called");
         }
         const k = obj[KEY];
@@ -46,7 +46,8 @@ class UnionField extends field_1.BaseField {
         };
     }
     async valid(obj) {
-        if (!(obj instanceof Object)) {
+        // Accept the same record shapes as the member struct fields.
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
             return false;
         }
         let promises = [];

package/scripts/custom_graphql.js

@@ -533,7 +533,10 @@ async function main() {
     });
 }
 main()
-    .then()
+    // Imported application modules can leave database pools or other handles open.
+    // The awaited stdout write above is the script's final required work, so exit
+    // explicitly instead of waiting for the event loop to drain.
+    .then(() => (0, process_1.exit)(0))
     .catch((err) => {
     console.error(err);
     (0, process_1.exit)(1);

package/testutils/db/temp_db.js

@@ -627,13 +627,14 @@ function setupSqlite(connString, tables, opts) {
             const client = await db_1.default.getInstance().getNewClient();
             for (const [key, _] of tdb.__getTables()) {
                 const query = `delete from ${key}`;
-                if (isSyncClient(client))
+                if (isSyncClient(client)) {
                     if (client.execSync) {
                         client.execSync(query);
                     }
                     else {
                         await client.exec(query);
                     }
+                }
             }
         });
     }