@snowtop/ent 0.0.32-alpha.5 → 0.1.0-alpha

package/action/action.d.ts

@@ -14,6 +14,7 @@ export interface Builder<T extends Ent> {
     build(): Promise<Changeset<T>>;
     operation: WriteOperation;
     editedEnt?(): Promise<T | null>;
+    nodeType: string;
 }
 export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
     placeholderID: ID;
@@ -31,24 +32,24 @@ export interface Changeset<T extends Ent> {
     dependencies?: Map<ID, Builder<Ent>>;
 }
 export declare type TriggerReturn = void | Promise<Changeset<Ent> | void | (Changeset<Ent> | void)[]> | Promise<Changeset<Ent>>[];
-export interface Trigger<T extends Ent> {
-    changeset(builder: Builder<T>, input: Data): TriggerReturn;
+export interface Trigger<TBuilder extends Builder<Ent>, TData extends Data> {
+    changeset(builder: TBuilder, input: TData): TriggerReturn;
 }
-export interface Observer<T extends Ent> {
-    observe(builder: Builder<T>, input: Data): void | Promise<void>;
+export interface Observer<TBuilder extends Builder<Ent>, TData extends Data> {
+    observe(builder: TBuilder, input: TData): void | Promise<void>;
 }
-export interface Validator<T extends Ent> {
-    validate(builder: Builder<T>, input: Data): Promise<void> | void;
+export interface Validator<TBuilder extends Builder<Ent>, TData extends Data> {
+    validate(builder: TBuilder, input: TData): Promise<void> | void;
 }
-export interface Action<T extends Ent> {
+export interface Action<TEnt extends Ent, TBuilder extends Builder<TEnt>, TData extends Data> {
     readonly viewer: Viewer;
-    changeset(): Promise<Changeset<T>>;
-    builder: Builder<T>;
-    getPrivacyPolicy(): PrivacyPolicy;
-    triggers?: Trigger<T>[];
-    observers?: Observer<T>[];
-    validators?: Validator<T>[];
-    getInput(): Data;
+    changeset(): Promise<Changeset<TEnt>>;
+    builder: TBuilder;
+    getPrivacyPolicy(): PrivacyPolicy<TEnt>;
+    triggers?: Trigger<TBuilder, TData>[];
+    observers?: Observer<TBuilder, TData>[];
+    validators?: Validator<TBuilder, TData>[];
+    getInput(): TData;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     viewerForEntLoad?(data: Data): Viewer | Promise<Viewer>;

package/action/experimental_action.d.ts

@@ -1,8 +1,8 @@
 import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
-export interface ActionOptions<T extends Ent> {
+export interface ActionOptions<T extends Ent, TData extends Data> {
     existingEnt?: T | null;
-    input?: {};
+    input?: TData;
     operation?: WriteOperation;
 }
 interface EntBuilder<T extends Ent> extends Builder<T> {
@@ -13,28 +13,28 @@ interface EntBuilder<T extends Ent> extends Builder<T> {
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
 }
-export declare class BaseAction<T extends Ent> implements Action<T> {
+export declare class BaseAction<TEnt extends Ent, TData extends Data> implements Action<TEnt, EntBuilder<TEnt>, TData> {
     viewer: Viewer;
-    builderCtr: BuilderConstructor<T>;
-    builder: EntBuilder<T>;
+    builderCtr: BuilderConstructor<TEnt, TData>;
+    builder: EntBuilder<TEnt>;
     private input;
-    triggers: Trigger<Ent>[];
-    observers: Observer<Ent>[];
-    validators: Validator<Ent>[];
-    getPrivacyPolicy(): import("../core/base").PrivacyPolicy;
-    constructor(viewer: Viewer, builderCtr: BuilderConstructor<T>, options?: ActionOptions<T> | null);
-    static createBuilder<T extends Ent>(viewer: Viewer, builderCtr: BuilderConstructor<T>, options?: ActionOptions<T> | null): Builder<T>;
-    static bulkAction<T extends Ent>(ent: T, builderCtr: BuilderConstructor<T>, ...actions: Action<Ent>[]): BaseAction<T>;
-    changeset(): Promise<Changeset<T>>;
+    triggers: Trigger<EntBuilder<TEnt>, TData>[];
+    observers: Observer<EntBuilder<TEnt>, TData>[];
+    validators: Validator<EntBuilder<TEnt>, TData>[];
+    getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent>;
+    constructor(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TData>, options?: ActionOptions<TEnt, TData> | null);
+    static createBuilder<TEnt extends Ent, TData extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TData>, options?: ActionOptions<TEnt, TData> | null): Builder<TEnt>;
+    static bulkAction<TEnt extends Ent, TData extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TData>, ...actions: Action<Ent, Builder<Ent>, Data>[]): BaseAction<TEnt, TData>;
+    changeset(): Promise<Changeset<TEnt>>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
-    save(): Promise<T | null>;
-    saveX(): Promise<T>;
-    getInput(): {};
+    save(): Promise<TEnt | null>;
+    saveX(): Promise<TEnt>;
+    getInput(): TData;
 }
-interface BuilderConstructor<T extends Ent> {
-    new (viewer: Viewer, operation: WriteOperation, action: Action<T>, existingEnt?: T | undefined): EntBuilder<T>;
+interface BuilderConstructor<TEnt extends Ent, TData extends Data> {
+    new (viewer: Viewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt>, TData>, existingEnt?: TEnt | undefined): EntBuilder<TEnt>;
 }
-export declare function updateRawObject<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
-export declare function getSimpleEditAction<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Action<TEnt>;
+export declare function updateRawObject<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TInput>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function getSimpleEditAction<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TInput>, existingEnt: TEnt, input: TInput): Action<TEnt, Builder<TEnt>, TInput>;
 export {};

package/action/experimental_action.js

@@ -37,7 +37,7 @@ class BaseAction {
         });
         action.triggers = [
             {
-                changeset: (builder, _input) => {
+                changeset: () => {
                     return actions.map((action) => action.changeset());
                 },
             },

package/action/orchestrator.d.ts

@@ -3,14 +3,14 @@ import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
 import { SchemaInputType } from "../schema/schema";
 import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
-export interface OrchestratorOptions<T extends Ent, TData extends Data> {
+export interface OrchestratorOptions<TEnt extends Ent, TData extends Data> {
     viewer: Viewer;
     operation: WriteOperation;
     tableName: string;
-    loaderOptions: LoadEntOptions<T>;
+    loaderOptions: LoadEntOptions<TEnt>;
     key: string;
-    builder: Builder<T>;
-    action?: Action<T>;
+    builder: Builder<TEnt>;
+    action?: Action<TEnt, Builder<TEnt>, TData>;
     schema: SchemaInputType;
     editedFields(): Map<string, any>;
     updateInput?: (data: TData) => void;
@@ -28,7 +28,7 @@ export declare enum edgeDirection {
     inboundEdge = 0,
     outboundEdge = 1
 }
-export declare class Orchestrator<T extends Ent> {
+export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
     private options;
     private edgeSet;
     private edges;
@@ -41,7 +41,7 @@ export declare class Orchestrator<T extends Ent> {
     viewer: Viewer;
     private defaultFieldsByFieldName;
     private defaultFieldsByTSName;
-    constructor(options: OrchestratorOptions<T, Data>);
+    constructor(options: OrchestratorOptions<TEnt, TData>);
     private addEdge;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
@@ -64,11 +64,11 @@ export declare class Orchestrator<T extends Ent> {
     private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
-    build(): Promise<EntChangeset<T>>;
+    build(): Promise<EntChangeset<TEnt>>;
     private viewerForEntLoad;
     returnedRow(): Promise<Data | null>;
-    editedEnt(): Promise<T | null>;
-    editedEntX(): Promise<T>;
+    editedEnt(): Promise<TEnt | null>;
+    editedEntX(): Promise<TEnt>;
 }
 export declare class EntChangeset<T extends Ent> implements Changeset<T> {
     viewer: Viewer;

package/core/base.d.ts

@@ -43,7 +43,7 @@ export interface Viewer {
 export interface Ent {
     id: ID;
     viewer: Viewer;
-    privacyPolicy: PrivacyPolicy;
+    privacyPolicy: PrivacyPolicy<this>;
     nodeType: string;
 }
 export declare type Data = {
@@ -92,6 +92,12 @@ export interface LoadEntOptions<T extends Ent> extends LoadableEntOptions<T>, Se
 export interface LoadCustomEntOptions<T extends Ent> extends SelectBaseDataOptions {
     ent: EntConstructor<T>;
 }
+export interface LoaderInfo {
+    tableName: string;
+    fields: string[];
+    nodeType: string;
+    loaderFactory: LoaderFactory<any, Data | null>;
+}
 export interface EditEntOptions<T extends Ent> extends LoadableEntOptions<T>, EditRowOptions {
 }
 declare enum privacyResult {
@@ -104,17 +110,17 @@ export interface PrivacyResult {
     error?: PrivacyError;
 }
 export interface PrivacyError extends Error {
-    privacyPolicy: PrivacyPolicy;
+    privacyPolicy: PrivacyPolicy<Ent>;
     ent?: Ent;
 }
 export declare function Allow(): PrivacyResult;
 export declare function Skip(): PrivacyResult;
 export declare function Deny(): PrivacyResult;
 export declare function DenyWithReason(e: PrivacyError): PrivacyResult;
-export interface PrivacyPolicyRule {
-    apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
+export interface PrivacyPolicyRule<TEnt extends Ent = Ent> {
+    apply(v: Viewer, ent?: TEnt): Promise<PrivacyResult>;
 }
-export interface PrivacyPolicy {
-    rules: PrivacyPolicyRule[];
+export interface PrivacyPolicy<TEnt extends Ent = Ent> {
+    rules: PrivacyPolicyRule<TEnt>[];
 }
 export {};

package/core/ent.d.ts

@@ -10,7 +10,8 @@ export declare function loadEntX<T extends Ent>(viewer: Viewer, id: ID, options:
 export declare function loadEntXViaKey<T extends Ent>(viewer: Viewer, key: any, options: LoadEntOptions<T>): Promise<T>;
 export declare function loadEntFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T | null>;
 export declare function loadEntXFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T>;
-export declare function loadEnts<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<T[]>;
+export declare function loadEnts<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<Map<ID, T>>;
+export declare function loadEntsList<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<T[]>;
 export declare function loadEntsFromClause<T extends Ent>(viewer: Viewer, clause: clause.Clause, options: LoadEntOptions<T>): Promise<Map<ID, T>>;
 export declare function loadCustomEnts<T extends Ent>(viewer: Viewer, options: LoadCustomEntOptions<T>, query: CustomQuery): Promise<T[]>;
 interface rawQueryOptions {

package/core/ent.js

@@ -22,7 +22,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.loadEdges = exports.defaultEdgeQueryOptions = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.EditNodeOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.applyPrivacyPolicyForEntX = exports.applyPrivacyPolicyForEnt = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = void 0;
+exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.loadEdges = exports.defaultEdgeQueryOptions = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.EditNodeOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.applyPrivacyPolicyForEntX = exports.applyPrivacyPolicyForEnt = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = void 0;
+exports.getEdgeTypeInGroup = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const clause = __importStar(require("./clause"));
@@ -145,7 +146,7 @@ async function loadEntXFromClause(viewer, options, clause) {
 exports.loadEntXFromClause = loadEntXFromClause;
 async function loadEnts(viewer, options, ...ids) {
     if (!ids.length) {
-        return [];
+        return new Map();
     }
     let loaded = false;
     let rows = [];
@@ -175,12 +176,16 @@ async function loadEnts(viewer, options, ...ids) {
         // this is always "id" if not using an ObjectLoaderFactory
         clause.In("id", ...ids), options);
     }
+    return m;
     // TODO do we want to change this to be a map not a list so that it's easy to check for existence?
     // TODO eventually this should be doing a cache then db queyr and maybe depend on dataloader to get all the results at once
-    // we need to get the result and re-sort... because the raw db access doesn't guarantee it in same order
-    // apparently
-    //  let m = await loadEntsFromClause(viewer, clause.In("id", ...ids), options);
-    let result = [];
+}
+exports.loadEnts = loadEnts;
+// calls loadEnts and returns the results sorted in the order they were passed in
+// useful for EntQuery and other paths where the order matters
+async function loadEntsList(viewer, options, ...ids) {
+    const m = await loadEnts(viewer, options, ...ids);
+    const result = [];
     ids.forEach((id) => {
         let ent = m.get(id);
         if (ent) {
@@ -189,7 +194,7 @@ async function loadEnts(viewer, options, ...ids) {
     });
     return result;
 }
-exports.loadEnts = loadEnts;
+exports.loadEntsList = loadEntsList;
 // we return a map here so that any sorting for queries that exist
 // can be done in O(N) time
 async function loadEntsFromClause(viewer, clause, options) {
@@ -1133,7 +1138,7 @@ async function loadNodesByEdge(viewer, id1, edgeType, options) {
     });
     // extract id2s
     const ids = rows.map((row) => row.id2);
-    return loadEnts(viewer, options, ...ids);
+    return loadEntsList(viewer, options, ...ids);
 }
 exports.loadNodesByEdge = loadNodesByEdge;
 async function applyPrivacyPolicyForRow(viewer, options, row) {

package/core/query/assoc_query.js

@@ -73,7 +73,7 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
             }
             let promises = [];
             for (const [_, value] of m) {
-                promises.push((0, ent_1.loadEnts)(this.viewer, value.options, ...value.ids));
+                promises.push((0, ent_1.loadEntsList)(this.viewer, value.options, ...value.ids));
             }
             const entss = await Promise.all(promises);
             const r = [];
@@ -83,7 +83,7 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
             return r;
         }
         const ids = edges.map((edge) => edge.id2);
-        return await (0, ent_1.loadEnts)(this.viewer, this.options, ...ids);
+        return (0, ent_1.loadEntsList)(this.viewer, this.options, ...ids);
     }
     dataToID(edge) {
         return edge.id2;

package/core/query/query.d.ts

@@ -41,7 +41,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private idMap;
     private idsToFetch;
     constructor(viewer: Viewer, sortCol: string);
-    getPrivacyPolicy(): PrivacyPolicy;
+    getPrivacyPolicy(): PrivacyPolicy<Ent>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
     last(n: number, before?: string): this;

package/graphql/index.d.ts

@@ -6,5 +6,5 @@ export { GraphQLEdgeType, GraphQLConnectionType, } from "./query/connection_type
 export { GraphQLNodeInterface } from "./builtins/node";
 export { GraphQLConnectionInterface } from "./builtins/connection";
 export { GraphQLEdgeInterface } from "./builtins/edge";
-export { NodeResolver, EntNodeResolver, registerResolver, clearResolvers, resolveID, nodeIDEncoder, mustDecodeIDFromGQLID, encodeGQLID, } from "./node_resolver";
+export { NodeResolver, EntNodeResolver, registerResolver, clearResolvers, resolveID, nodeIDEncoder, mustDecodeIDFromGQLID, mustDecodeNullableIDFromGQLID, encodeGQLID, } from "./node_resolver";
 export { convertFromGQLEnum, convertToGQLEnum } from "./enums";

package/graphql/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToGQLEnum = exports.convertFromGQLEnum = exports.encodeGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLTime = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = void 0;
+exports.convertToGQLEnum = exports.convertFromGQLEnum = exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLTime = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = void 0;
 var graphql_1 = require("./graphql");
 Object.defineProperty(exports, "gqlField", { enumerable: true, get: function () { return graphql_1.gqlField; } });
 Object.defineProperty(exports, "gqlArg", { enumerable: true, get: function () { return graphql_1.gqlArg; } });
@@ -35,6 +35,7 @@ Object.defineProperty(exports, "clearResolvers", { enumerable: true, get: functi
 Object.defineProperty(exports, "resolveID", { enumerable: true, get: function () { return node_resolver_1.resolveID; } });
 Object.defineProperty(exports, "nodeIDEncoder", { enumerable: true, get: function () { return node_resolver_1.nodeIDEncoder; } });
 Object.defineProperty(exports, "mustDecodeIDFromGQLID", { enumerable: true, get: function () { return node_resolver_1.mustDecodeIDFromGQLID; } });
+Object.defineProperty(exports, "mustDecodeNullableIDFromGQLID", { enumerable: true, get: function () { return node_resolver_1.mustDecodeNullableIDFromGQLID; } });
 Object.defineProperty(exports, "encodeGQLID", { enumerable: true, get: function () { return node_resolver_1.encodeGQLID; } });
 var enums_1 = require("./enums");
 Object.defineProperty(exports, "convertFromGQLEnum", { enumerable: true, get: function () { return enums_1.convertFromGQLEnum; } });

package/graphql/node_resolver.d.ts

@@ -24,5 +24,6 @@ export declare function clearResolvers(): Promise<void>;
 export declare function resolveID(viewer: Viewer, id: string): Promise<Node | null>;
 export declare const nodeIDEncoder: GraphQLFieldResolver<Ent, {}>;
 export declare function mustDecodeIDFromGQLID(id: string): ID;
+export declare function mustDecodeNullableIDFromGQLID(id: string | null | undefined): any;
 export declare function encodeGQLID(node: Ent): string;
 export {};

package/graphql/node_resolver.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = void 0;
+exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = void 0;
 class EntNodeResolver {
     constructor(loader) {
         this.loader = loader;
@@ -76,6 +76,19 @@ function mustDecodeIDFromGQLID(id) {
     return decoded;
 }
 exports.mustDecodeIDFromGQLID = mustDecodeIDFromGQLID;
+// TODO get the right (non-any) return type here. may need to change codegen to do the right thing here
+function mustDecodeNullableIDFromGQLID(id) {
+    // support undefined because fields in action
+    if (id === null || id === undefined) {
+        return id;
+    }
+    const decoded = EntNodeResolver.decode(id);
+    if (!decoded) {
+        throw new Error(`wasn't able to decode invalid ${id}`);
+    }
+    return decoded;
+}
+exports.mustDecodeNullableIDFromGQLID = mustDecodeNullableIDFromGQLID;
 // This takes an ent and returns the graphql id
 function encodeGQLID(node) {
     // let's do 3 parts. we take the "node" prefix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.32-alpha.5",
+  "version": "0.1.0-alpha",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.d.ts

@@ -1,4 +1,4 @@
-import { Schema, AssocEdge, AssocEdgeGroup, Action } from "../schema";
+import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
 import { ActionField } from "../schema/schema";
 declare enum NullableResult {
     CONTENTS = "contents",
@@ -12,10 +12,11 @@ declare type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActi
     patternName?: string;
     edgeActions?: OutputAction[];
 };
-declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups"> & {
+declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & {
     actions: OutputAction[];
     assocEdges: ProcessedAssocEdge[];
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
+    fields: ProcessedField[];
 };
 declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -29,7 +30,13 @@ interface schemasDict {
 interface ProcessedPattern {
     name: string;
     assocEdges: ProcessedAssocEdge[];
+    fields: ProcessedField[];
 }
+declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate"> & {
+    hasDefaultValueOnCreate?: boolean;
+    hasDefaultValueOnEdit?: boolean;
+    patternName?: string;
+};
 interface patternsDict {
     [key: string]: ProcessedPattern;
 }

package/parse_schema/parse.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
-function processFields(processedSchema, src) {
+function processFields(src, patternName) {
+    const ret = [];
     for (const field of src) {
         let f = { ...field };
-        f["hasDefaultValueOnCreate"] = field.defaultValueOnCreate != undefined;
-        f["hasDefaultValueOnEdit"] = field.defaultValueOnEdit != undefined;
+        f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
+        f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
         if (field.polymorphic) {
             // convert boolean into object
             // we keep boolean as an option to keep API simple
             if (typeof field.polymorphic === "boolean") {
-                f["polymorphic"] = {};
+                f.polymorphic = {};
             }
             else {
-                f["polymorphic"] = field.polymorphic;
+                f.polymorphic = field.polymorphic;
             }
         }
         // convert string to object to make API consumed by go simple
@@ -24,16 +25,22 @@ function processFields(processedSchema, src) {
                 };
             }
         }
-        processedSchema.fields.push(f);
+        if (patternName) {
+            f.patternName = patternName;
+        }
+        ret.push(f);
     }
+    return ret;
 }
-function processEdges(dst, src, patternName) {
+function processEdges(src, patternName) {
+    const ret = [];
     for (const edge of src) {
         let edge2 = { ...edge };
         edge2.edgeActions = edge.edgeActions?.map((action) => processAction(action));
         edge2.patternName = patternName;
-        dst.push(edge2);
+        ret.push(edge2);
     }
+    return ret;
 }
 function processEdgeGroups(processedSchema, edgeGroups) {
     // array-ify this
@@ -49,26 +56,26 @@ function processEdgeGroups(processedSchema, edgeGroups) {
     }
 }
 function processPattern(patterns, pattern, processedSchema) {
-    // TODO kill
-    let name = pattern.name || "node";
+    const name = pattern.name;
+    const fields = processFields(pattern.fields, pattern.name);
+    processedSchema.fields.push(...fields);
+    if (pattern.edges) {
+        const edges = processEdges(pattern.edges, pattern.name);
+        processedSchema.assocEdges.push(...edges);
+    }
     if (patterns[name] === undefined) {
-        const edges = [];
-        if (pattern.edges) {
-            processEdges(edges, pattern.edges);
-        }
+        // intentionally processing separately and not passing pattern.name
+        const edges = processEdges(pattern.edges || []);
         patterns[name] = {
             name: pattern.name,
             assocEdges: edges,
+            fields: fields,
         };
     }
     else {
         // TODO ideally we want to make sure that different patterns don't have the same name
         // can't do a deepEqual check because function calls and therefore different instances in fields
     }
-    processFields(processedSchema, pattern.fields);
-    if (pattern.edges) {
-        processEdges(processedSchema.assocEdges, pattern.edges, pattern.name);
-    }
 }
 var NullableResult;
 (function (NullableResult) {
@@ -133,9 +140,11 @@ function parseSchema(potentialSchemas) {
                 processPattern(patterns, pattern, processedSchema);
             }
         }
-        processFields(processedSchema, schema.fields);
+        const fields = processFields(schema.fields);
+        processedSchema.fields.push(...fields);
         if (schema.edges) {
-            processEdges(processedSchema.assocEdges, schema.edges);
+            const edges = processEdges(schema.edges);
+            processedSchema.assocEdges.push(...edges);
         }
         if (schema.edgeGroups) {
             processEdgeGroups(processedSchema, schema.edgeGroups);

package/schema/field.d.ts

@@ -144,7 +144,7 @@ export declare class ListField extends BaseField {
     private validators;
     constructor(field: Field, options: FieldOptions);
     validate(validator: (val: any[]) => boolean): this;
-    valid(val: any): boolean;
+    valid(val: any): Promise<boolean>;
     private postgresVal;
     format(val: any): any;
     minLen(l: number): this;

package/schema/field.js

@@ -22,9 +22,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UUIDListType = exports.EnumListType = exports.DateListType = exports.TimetzListType = exports.TimeListType = exports.TimestamptzListType = exports.TimestampListType = exports.BooleanListType = exports.BigIntegerListType = exports.FloatListType = exports.IntegerListType = exports.IntListType = exports.StringListType = exports.ListField = exports.EnumType = exports.EnumField = exports.DateType = exports.DateField = exports.TimetzType = exports.TimeType = exports.TimeField = exports.leftPad = exports.TimestamptzType = exports.TimestampType = exports.TimestampField = exports.StringType = exports.StringField = exports.BooleanType = exports.BooleanField = exports.FloatType = exports.FloatField = exports.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
 const luxon_1 = require("luxon");
 const snake_case_1 = require("snake-case");
-const camel_case_1 = require("camel-case");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
+const util_1 = require("util");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -83,8 +83,8 @@ class UUIDField extends BaseField {
             }
         }
         if (options.fieldEdge?.enforceSchema &&
-            !options.fieldEdge.getLoaderOptions) {
-            throw new Error(`cannot enforceSchema if getLoaderOptions wasn't passed in`);
+            !options.fieldEdge.getLoaderInfoFromSchema) {
+            throw new Error(`cannot enforceSchema if getLoaderInfoFromSchema wasn't passed in`);
         }
     }
     isBuilder(val) {
@@ -94,19 +94,17 @@ class UUIDField extends BaseField {
         if (!this.options.fieldEdge?.enforceSchema) {
             return true;
         }
-        // TODO #510 consistency.
-        const f = (0, camel_case_1.camelCase)(this.options.fieldEdge.schema);
-        const getLoaderOptions = this.options.fieldEdge.getLoaderOptions;
-        const loadRowOptions = getLoaderOptions(f);
-        if (!loadRowOptions) {
-            throw new Error(`couldn't get loaderOptions for ${f}`);
+        const getLoaderInfo = this.options.fieldEdge.getLoaderInfoFromSchema;
+        const loaderInfo = getLoaderInfo(this.options.fieldEdge.schema);
+        if (!loaderInfo) {
+            throw new Error(`couldn't get loaderInfo for ${this.options.fieldEdge.schema}`);
         }
         if (this.isBuilder(val)) {
-            // if builder, the ent type of the builder and the ent type returned by the load constructor should match
-            return val.ent === loadRowOptions.ent;
+            // if builder, the nodeType of the builder and the nodeType of the loaderInfo should match
+            return val.nodeType === loaderInfo.nodeType;
         }
         // TODO we need context here to make sure that we hit local cache
-        const row = await loadRowOptions.loaderFactory.createLoader().load(val);
+        const row = await loaderInfo.loaderFactory.createLoader().load(val);
         return row !== null;
     }
 }
@@ -570,7 +568,7 @@ class ListField extends BaseField {
         this.validators.push(validator);
         return this;
     }
-    valid(val) {
+    async valid(val) {
         if (!Array.isArray(val)) {
             return false;
         }
@@ -579,15 +577,18 @@ class ListField extends BaseField {
                 return false;
             }
         }
-        if (!this.field.valid) {
+        const valid = this.field.valid;
+        if (!valid) {
             return true;
         }
-        for (const v of val) {
-            if (!this.field.valid(v)) {
-                return false;
-            }
+        const res = valid.apply(this.field, [val[0]]);
+        if (util_1.types.isPromise(res)) {
+            const ret = await Promise.all(val.map(async (v) => await valid.apply(this.field, [v])));
+            return ret.every((v) => v);
         }
-        return true;
+        const ret = val.map((v) => valid.apply(this.field, [v]));
+        const result = ret.every((v) => v);
+        return result;
     }
     postgresVal(val, jsonType) {
         if (!jsonType) {

package/schema/schema.d.ts

@@ -1,4 +1,4 @@
-import { Data, Ent, LoadEntOptions } from "../core/base";
+import { Data, Ent, LoaderInfo } from "../core/base";
 import { Builder } from "../action/action";
 export default interface Schema {
     fields: Field[];
@@ -102,7 +102,7 @@ export interface ForeignKey {
     disableIndex?: boolean;
     disableBuilderType?: boolean;
 }
-declare type getLoaderOptionsFn = (type: any) => LoadEntOptions<Ent>;
+declare type getLoaderInfoFn = (type: string) => LoaderInfo;
 export interface InverseFieldEdge {
     name: string;
     edgeConstName?: string;
@@ -113,7 +113,7 @@ export interface FieldEdge {
     schema: string;
     inverseEdge?: string | InverseFieldEdge;
     enforceSchema?: boolean;
-    getLoaderOptions?: getLoaderOptionsFn;
+    getLoaderInfoFromSchema?: getLoaderInfoFn;
     disableBuilderType?: boolean;
 }
 export interface FieldOptions {
@@ -171,6 +171,7 @@ export interface ActionField {
     nullable?: boolean | NullableListOptions;
     list?: boolean;
     actionName?: string;
+    excludedFields?: string[];
 }
 export interface Action {
     operation: ActionOperation;

package/testutils/builder.d.ts

@@ -8,7 +8,7 @@ export declare class User implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy;
+    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
     firstName: string;
     constructor(viewer: Viewer, data: Data);
 }
@@ -18,7 +18,7 @@ export declare class Event implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy;
+    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Contact implements Ent {
@@ -27,7 +27,7 @@ export declare class Contact implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy;
+    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Group implements Ent {
@@ -36,7 +36,7 @@ export declare class Group implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy;
+    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Message implements Ent {
@@ -45,7 +45,7 @@ export declare class Message implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy;
+    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Address implements Ent {
@@ -54,7 +54,7 @@ export declare class Address implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy;
+    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
     constructor(viewer: Viewer, data: Data);
 }
 export interface BuilderSchema<T extends Ent> extends Schema {
@@ -69,9 +69,10 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     existingEnt: T | undefined;
     ent: EntConstructor<T>;
     placeholderID: ID;
-    orchestrator: Orchestrator<T>;
+    orchestrator: Orchestrator<T, Data>;
     fields: Map<string, any>;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T> | undefined);
+    nodeType: string;
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T, SimpleBuilder<T>, Data> | undefined);
     build(): Promise<Changeset<T>>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
@@ -83,16 +84,16 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
 interface viewerEntLoadFunc {
     (data: Data): Viewer | Promise<Viewer>;
 }
-export declare class SimpleAction<T extends Ent> implements Action<T> {
+export declare class SimpleAction<T extends Ent> implements Action<T, SimpleBuilder<T>, Data> {
     viewer: Viewer;
     private fields;
     builder: SimpleBuilder<T>;
-    validators: Validator<T>[];
-    triggers: Trigger<T>[];
-    observers: Observer<T>[];
+    validators: Validator<SimpleBuilder<T>, Data>[];
+    triggers: Trigger<SimpleBuilder<T>, Data>[];
+    observers: Observer<SimpleBuilder<T>, Data>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined);
-    getPrivacyPolicy(): import("../core/base").PrivacyPolicy;
+    getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent>;
     getInput(): Data;
     changeset(): Promise<Changeset<T>>;
     valid(): Promise<boolean>;

package/testutils/builder.js

@@ -13,6 +13,7 @@ const pluralize_1 = __importDefault(require("pluralize"));
 const snake_case_1 = require("snake-case");
 const loaders_1 = require("../core/loaders");
 const convert_1 = require("../core/convert");
+const camel_case_1 = require("camel-case");
 class User {
     constructor(viewer, data) {
         this.viewer = viewer;
@@ -126,6 +127,7 @@ class SimpleBuilder {
         }
         this.ent = schema.ent;
         const tableName = getTableName(schema);
+        this.nodeType = (0, camel_case_1.camelCase)(schema.ent.name);
         this.orchestrator = new orchestrator_1.Orchestrator({
             viewer: this.viewer,
             operation: operation,

package/testutils/ent-graphql-tests/index.d.ts

@@ -27,6 +27,7 @@ export declare function expectQueryFromRoot(config: queryRootConfig, ...options:
 export interface mutationRootConfig extends queryConfig {
     mutation: string;
     disableInputWrapping?: boolean;
+    nullQueryPaths?: string[];
 }
 export declare function expectMutation(config: mutationRootConfig, ...options: Option[]): Promise<supertest.SuperTest<supertest.Test>>;
 export {};

package/testutils/fake_data/user_query.d.ts

@@ -53,7 +53,7 @@ export declare class UserToFriendRequestsQuery extends AssocEdgeQueryBase<FakeUs
 }
 export declare class UserToIncomingFriendRequestsQuery extends AssocEdgeQueryBase<FakeUser, FakeUser, AssocEdge> {
     constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>);
-    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy;
+    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent>;
     sourceEnt(id: ID): Promise<FakeUser | null>;
     static query(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>): UserToIncomingFriendRequestsQuery;
     queryContacts(): UserToContactsQuery;
@@ -90,7 +90,7 @@ export declare class UserToEventsInNextWeekQuery extends CustomEdgeQueryBase<Fak
     constructor(viewer: Viewer, src: ID | FakeUser);
     static query(viewer: Viewer, src: FakeUser | ID): UserToEventsInNextWeekQuery;
     sourceEnt(id: ID): Promise<FakeUser | null>;
-    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy;
+    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent>;
 }
 export declare class UserToFollowingQuery extends AssocEdgeQueryBase<FakeUser, Ent, AssocEdge> {
     constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>);

package/testutils/parse_sql.js

@@ -121,6 +121,22 @@ function getDataToReturn(data, colNames, returningAll) {
     return ret;
 }
 exports.getDataToReturn = getDataToReturn;
+function processBeforeStoring(val) {
+    if (typeof val !== "string") {
+        return val;
+    }
+    // convert postgres lists into lists before storing
+    if (val[0] === "{" && val[val.length - 1] === "}") {
+        try {
+            // valid json, don't convert
+            JSON.parse(val);
+        }
+        catch (e) {
+            return val.substring(1, val.length - 1).split(",");
+        }
+    }
+    return val;
+}
 function parseInsertStatement(ast, values, // values passed to query
 returningAll) {
     const tableName = getTableName(ast.table);
@@ -138,7 +154,7 @@ returningAll) {
     // INSERT INTO tableName (cols) VALUES (pos args)
     for (let i = 0; i < columns.length; i++) {
         let col = columns[i];
-        data[col] = values[i];
+        data[col] = processBeforeStoring(values[i]);
     }
     let returningData = null;
     if (returningAll) {
@@ -411,7 +427,7 @@ function parseUpdateStatement(ast, values, map, returningAll) {
     for (const set of ast.set) {
         let col = set.column;
         let value = getValueFromRegex(set.value, values);
-        overwrite[col] = value;
+        overwrite[col] = processBeforeStoring(value);
     }
     let columns = new Set();
     if (ast.returning) {