@snowtop/ent 0.2.13 → 0.2.15

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, defaultKeys?: ReadonlySet<string>) => 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());
@@ -599,6 +708,8 @@ class Orchestrator {
     async getFieldsWithDefaultValues(builder, schemaFields, editedFields, action) {
         let data = {};
         let defaultData = {};
+        const defaultKeys = new Set();
+        const transformedFields = new Set();
         let input = action?.getInput() || {};
         let updateInput = false;
         // transformations
@@ -606,6 +717,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...
@@ -649,6 +762,7 @@ class Orchestrator {
                     }
                     data[this.getStorageKey(k)] = dbVal;
                     if (!field.immutable) {
+                        transformedFields.add(k);
                         this.defaultFieldsByTSName[this.getInputKey(k)] = inputVal;
                     }
                     // hmm do we need this?
@@ -668,6 +782,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();
@@ -679,7 +800,7 @@ class Orchestrator {
             if (value !== undefined) {
                 userDefinedKeys.add(dbKey);
             }
-            if (value === undefined) {
+            if (value === undefined && !transformedFields.has(fieldName)) {
                 if (this.actualOperation === action_1.WriteOperation.Insert) {
                     if (field.defaultToViewerOnCreate && field.defaultValueOnCreate) {
                         throw new Error(`cannot set both defaultToViewerOnCreate and defaultValueOnCreate`);
@@ -718,6 +839,9 @@ class Orchestrator {
                 }
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
                 this.defaultFieldsByTSName[this.getInputKey(fieldName)] = defaultValue;
+                if (field.disableUserEditable || updateOnlyIfOther) {
+                    defaultKeys.add(this.getInputKey(fieldName));
+                }
             }
         }
         // if there's data changing, add data
@@ -728,7 +852,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, defaultKeys);
             }
         }
         return { data, userDefinedKeys };
@@ -764,7 +888,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 +903,7 @@ class Orchestrator {
                     valid = await valid;
                 }
                 if (!valid) {
-                    return new Error(`invalid field ${fieldName} with value ${value}`);
+                    return invalidFieldError(fieldName, value);
                 }
             }
             if (field.format) {
@@ -823,6 +947,12 @@ class Orchestrator {
         for (const fieldName of needsFullDataChecks) {
             const field = schemaFields.get(fieldName);
             let value = editedFields.get(fieldName);
+            // Deferred defaults are absent from editedFields, but validators must
+            // still receive the value that will be saved when this operation writes.
+            if (value === undefined &&
+                (op === action_1.WriteOperation.Insert || this.hasData(data))) {
+                value = this.defaultFieldsByFieldName[fieldName];
+            }
             // @ts-ignore...
             // type hackery because it's hard
             const v = await field.validateWithFullData(value, this.options.builder);
@@ -855,6 +985,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -18,7 +18,7 @@
     "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",

package/schema/base_schema.js

@@ -3,26 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.EntSchemaWithTZ = exports.EntSchema = exports.Node = exports.Timestamps = void 0;
 const uuid_1 = require("uuid");
 const field_1 = require("./field");
-let tsFields = {
-    createdAt: (0, field_1.TimestampType)({
-        hideFromGraphQL: true,
-        disableUserEditable: true,
-        defaultValueOnCreate: () => {
-            return new Date();
-        },
-    }),
-    updatedAt: (0, field_1.TimestampType)({
-        hideFromGraphQL: true,
-        disableUserEditable: true,
-        defaultValueOnCreate: () => {
-            return new Date();
-        },
-        onlyUpdateIfOtherFieldsBeingSet_BETA: true,
-        defaultValueOnEdit: () => {
-            return new Date();
-        },
-    }),
-};
+function timestampFields(withTimezone) {
+    return {
+        createdAt: (0, field_1.TimestampType)({
+            withTimezone,
+            hideFromGraphQL: true,
+            disableUserEditable: true,
+            defaultValueOnCreate: () => {
+                return new Date();
+            },
+        }),
+        updatedAt: (0, field_1.TimestampType)({
+            withTimezone,
+            hideFromGraphQL: true,
+            disableUserEditable: true,
+            defaultValueOnCreate: () => {
+                return new Date();
+            },
+            onlyUpdateIfOtherFieldsBeingSet_BETA: true,
+            defaultValueOnEdit: () => {
+                return new Date();
+            },
+        }),
+    };
+}
+let tsFields = timestampFields(false);
 // Timestamps is a Pattern that adds a createdAt and updatedAt timestamp fields to the ent
 exports.Timestamps = {
     name: "timestamps",
@@ -43,25 +48,7 @@ let nodeFields = {
 let nodeFieldsWithTZ = {
     // inconsistent naming :(
     id: nodeField,
-    createdAt: (0, field_1.TimestampType)({
-        hideFromGraphQL: true,
-        disableUserEditable: true,
-        defaultValueOnCreate: () => {
-            return new Date();
-        },
-        withTimezone: true,
-    }),
-    updatedAt: (0, field_1.TimestampType)({
-        hideFromGraphQL: true,
-        disableUserEditable: true,
-        defaultValueOnCreate: () => {
-            return new Date();
-        },
-        defaultValueOnEdit: () => {
-            return new Date();
-        },
-        withTimezone: true,
-    }),
+    ...timestampFields(true),
 };
 // Node is a Pattern that adds 3 fields to the ent: (id, createdAt, and updatedAt timestamps)
 exports.Node = {

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/builder.d.ts

@@ -81,6 +81,7 @@ export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNu
     placeholderID: ID;
     orchestrator: Orchestrator<T, Data, Viewer, TExistingEnt>;
     fields: Map<string, any>;
+    private defaultInput;
     nodeType: string;
     m: Map<string, any>;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T, TExistingEnt>, Viewer, Data, TExistingEnt> | undefined, expressions?: Map<string, Clause>);

package/testutils/builder.js

@@ -191,6 +191,7 @@ class SimpleBuilder {
         this.schema = schema;
         this.operation = operation;
         this.existingEnt = existingEnt;
+        this.defaultInput = new Map();
         this.m = new Map();
         // create dynamic placeholder
         // TODO: do we need to use this as the node when there's an existingEnt
@@ -247,11 +248,18 @@ class SimpleBuilder {
                 // to simulate what we do in generated builders where we return a new Map
                 const m = new Map();
                 for (const [k, v] of this.fields) {
-                    m.set(k, v);
+                    if (!this.defaultInput.has(k) || this.defaultInput.get(k) !== v) {
+                        m.set(k, v);
+                    }
                 }
                 return m;
             },
-            updateInput: this.updateInput.bind(this),
+            updateInput: (input, _operation, defaultKeys) => {
+                this.updateInput(input);
+                for (const key of defaultKeys ?? []) {
+                    this.defaultInput.set(key, input[key]);
+                }
+            },
         });
     }
     getInput() {
@@ -264,6 +272,7 @@ class SimpleBuilder {
     updateInput(input) {
         const knownFields = (0, schema_1.getFields)(this.schema);
         for (const k in input) {
+            this.defaultInput.delete(k);
             if (knownFields.has(k)) {
                 this.fields.set(k, input[k]);
             }

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);
                     }
+                }
             }
         });
     }