@snowtop/ent 0.0.34 → 0.0.35

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/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.35",
   "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,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 +59,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 +94,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 +144,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);