@snowtop/ent 0.0.34 → 0.0.37

package/core/base.d.ts

@@ -108,6 +108,7 @@ declare enum privacyResult {
 export interface PrivacyResult {
     result: privacyResult;
     error?: PrivacyError;
+    getError?(policy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent): PrivacyError;
 }
 export interface PrivacyError extends Error {
     privacyPolicy: PrivacyPolicy;
@@ -116,7 +117,7 @@ export interface PrivacyError extends Error {
 export declare function Allow(): PrivacyResult;
 export declare function Skip(): PrivacyResult;
 export declare function Deny(): PrivacyResult;
-export declare function DenyWithReason(e: PrivacyError): PrivacyResult;
+export declare function DenyWithReason(e: PrivacyError | string): PrivacyResult;
 export interface PrivacyPolicyRule {
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }

package/core/base.js

@@ -30,7 +30,23 @@ function Deny() {
     return deny;
 }
 exports.Deny = Deny;
+class DenyWithReasonError extends Error {
+    constructor(privacyPolicy, rule, msg, ent) {
+        super(msg);
+        this.privacyPolicy = privacyPolicy;
+        this.privacyRule = rule;
+        this.ent = ent;
+    }
+}
 function DenyWithReason(e) {
+    if (typeof e === "string") {
+        return {
+            result: privacyResult.Deny,
+            getError(policy, rule, ent) {
+                return new DenyWithReasonError(policy, rule, e, ent);
+            },
+        };
+    }
     return {
         result: privacyResult.Deny,
         error: e,

package/core/loaders/assoc_edge_loader.d.ts

@@ -32,7 +32,7 @@ export declare class AssocEdgeLoaderFactory<T extends AssocEdge> implements Load
     name: string;
     constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T> | (() => AssocEdgeConstructor<T>));
     createLoader(context?: Context): AssocLoader<T>;
-    private isFunction;
+    private isConstructor;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): AssocLoader<T>;
 }
 export {};

package/core/loaders/assoc_edge_loader.js

@@ -161,16 +161,17 @@ class AssocEdgeLoaderFactory {
     createLoader(context) {
         return this.createConfigurableLoader({}, context);
     }
-    isFunction(edgeCtr) {
-        // not constructor
-        return !(edgeCtr.prototype && edgeCtr.prototype.constructor === edgeCtr);
+    isConstructor(edgeCtr) {
+        return (edgeCtr.prototype &&
+            edgeCtr.prototype.constructor &&
+            edgeCtr.prototype.constructor.name.length > 0);
     }
     createConfigurableLoader(options, context) {
         let edgeCtr = this.edgeCtr;
         // in generated code, the edge is not necessarily defined at the time of loading
         // so we call this as follows:
         // const loader = new AssocEdgeLoaderFactory(EdgeType.Foo, ()=>DerivedEdgeClass);
-        if (this.isFunction(edgeCtr)) {
+        if (!this.isConstructor(edgeCtr)) {
             edgeCtr = edgeCtr();
         }
         // rename to make TS happy

package/core/privacy.js

@@ -464,6 +464,9 @@ async function applyPrivacyPolicyX(v, policy, ent, throwErr) {
             if (res.error) {
                 throw res.error;
             }
+            if (res.getError) {
+                throw res.getError(policy, rule, ent);
+            }
             if (throwErr) {
                 throw throwErr();
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.34",
+  "version": "0.0.37",
   "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,21 +1,25 @@
 "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;
             }
         }
+        else {
+            delete f.polymorphic;
+        }
         // convert string to object to make API consumed by go simple
         if (f.fieldEdge && f.fieldEdge.inverseEdge) {
             if (typeof f.fieldEdge.inverseEdge === "string") {
@@ -24,16 +28,41 @@ function processFields(processedSchema, src) {
                 };
             }
         }
-        processedSchema.fields.push(f);
+        if (patternName) {
+            f.patternName = patternName;
+        }
+        transformType(field.type);
+        ret.push(f);
+    }
+    return ret;
+}
+function transformImportType(typ) {
+    if (!typ.importType) {
+        return;
+    }
+    typ.importType = {
+        ...typ.importType,
+        // these 2 needed for forwards compatibility with new go schema
+        importPath: typ.importType.path,
+        import: typ.importType.type,
+    };
+}
+function transformType(typ) {
+    if (!typ) {
+        return;
     }
+    transformImportType(typ);
+    transformType(typ.listElemType);
 }
-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 +78,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) {
@@ -84,6 +113,7 @@ function processAction(action) {
     let actionOnlyFields = action.actionOnlyFields.map((f) => {
         let f2 = f;
         if (!f.nullable) {
+            delete f2.nullable;
             return f2;
         }
         if (typeof f.nullable === "boolean") {
@@ -133,9 +163,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/schema.d.ts

@@ -82,6 +82,7 @@ export declare enum DBType {
 export interface ImportType {
     path: string;
     type: string;
+    [x: string]: any;
 }
 declare type EnumMap = {
     [key: string]: string;
@@ -131,6 +132,7 @@ export interface FieldOptions {
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
     disableUserEditable?: boolean;
+    disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
     defaultToViewerOnCreate?: boolean;
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;

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

@@ -16,6 +16,8 @@ interface queryConfig {
     callback?: (res: supertest.Response) => void;
     inlineFragmentRoot?: string;
     customHandlers?: RequestHandler[];
+    server?: any;
+    graphQLPath?: string;
 }
 export interface queryRootConfig extends queryConfig {
     root: string;

package/testutils/ent-graphql-tests/index.js

@@ -56,7 +56,7 @@ function server(config) {
         };
         return doWork();
     }));
-    app.use("/graphql", ...handlers);
+    app.use(config.graphQLPath || "/graphql", ...handlers);
     return app;
 }
 function getInnerType(typ, list) {
@@ -72,14 +72,14 @@ function makeGraphQLRequest(config, query, fieldArgs) {
     let test;
     if (config.test) {
         if (typeof config.test === "function") {
-            test = config.test(server(config));
+            test = config.test(config.server ? config.server : server(config));
         }
         else {
             test = config.test;
         }
     }
     else {
-        test = (0, supertest_1.default)(server(config));
+        test = (0, supertest_1.default)(config.server ? config.server : server(config));
     }
     let files = new Map();
     // handle files
@@ -104,7 +104,9 @@ function makeGraphQLRequest(config, query, fieldArgs) {
         }
     });
     if (files.size) {
-        let ret = test.post("/graphql").set(config.headers || {});
+        let ret = test
+            .post(config.graphQLPath || "/graphql")
+            .set(config.headers || {});
         ret.field("operations", JSON.stringify({
             query: query,
             variables: config.args,
@@ -130,7 +132,7 @@ function makeGraphQLRequest(config, query, fieldArgs) {
         return [
             test,
             test
-                .post("/graphql")
+                .post(config.graphQLPath || "/graphql")
                 .set(config.headers || {})
                 .send({
                 query: query,