@snowtop/ent 0.2.0-alpha.9 → 0.2.1

package/core/privacy.d.ts

@@ -119,18 +119,64 @@ export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
+export declare class AllowIfEdgeDoesNotExistRule implements PrivacyPolicyRule {
+    private id1;
+    private id2;
+    private edgeType;
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
+    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+}
+/**
+ * @deprecated use AllowIfEdgeExistsFromViewerToEntRule
+ * This is a privacy policy rule that checks if the viewer has an inbound edge to the ent.
+ * e.g. does edge exist from viewer's id to ent's id
+ */
 export declare class AllowIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
     private options?;
     constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer's id to ent's id
+ * Allows the viewer to see the ent if the edge exists
+ */
+export declare class AllowIfEdgeExistsFromViewerToEntRule extends AllowIfViewerInboundEdgeExistsRule {
+}
+/**
+ * @deprecated use AllowIfEdgeExistsFromEntToViewerRule
+ * This is a privacy policy rule that checks if the viewer has an outbound edge to the ent.
+ * e.g. does edge exist from ent's id to viewer's id
+ */
 export declare class AllowIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
     private options?;
     constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
+/**
+ * This is a privacy policy rule that checks if edge exists from ent's id to viewer's id
+ */
+export declare class AllowIfEdgeExistsFromEntToViewerRule extends AllowIfViewerOutboundEdgeExistsRule {
+}
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer to id of given ent property
+ */
+export declare class AllowIfEdgeExistsFromViewerToEntPropertyRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private edgeType;
+    private options?;
+    constructor(property: keyof T, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
+export declare class AllowIfEdgeExistsFromEntPropertyToViewerRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private edgeType;
+    private options?;
+    constructor(property: keyof T, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
 export declare class DenyIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
     private id2;
@@ -139,18 +185,67 @@ export declare class DenyIfEdgeExistsRule implements PrivacyPolicyRule {
     constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
+/**
+ * @deprecated use DenyIfEdgeExistsFromViewerToEntRule
+ */
 export declare class DenyIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
     private options?;
     constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer's id to ent's id
+ * Denies the viewer from seeing the ent if the edge exists
+ */
+export declare class DenyIfEdgeExistsFromViewerToEntRule extends DenyIfViewerInboundEdgeExistsRule {
+}
+/**
+ * @deprecated use DenyIfEdgeExistsFromEntToViewerRule
+ */
 export declare class DenyIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
     private options?;
     constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
+/**
+ * This is a privacy policy rule that checks if edge exists from ent's id to viewer's id
+ */
+export declare class DenyIfEdgeExistsFromEntToViewerRule extends DenyIfViewerOutboundEdgeExistsRule {
+}
+/**
+ * @deprecated use DenyIfEdgeExistsFromViewerToEntPropertyRule
+ */
+export declare class DenyIfViewerInboundEdgeToEntPropertyExistsRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private edgeType;
+    private options?;
+    constructor(property: keyof T, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer's id to ent's id
+ * Denies the viewer from seeing the ent if the edge exists
+ */
+export declare class DenyIfEdgeExistsFromViewerToEntPropertyRule<T extends Ent> extends DenyIfViewerInboundEdgeToEntPropertyExistsRule<T> {
+}
+/**
+ * @deprecated use DenyIfEdgeExistsFromEntToViewerPropertyRule
+ */
+export declare class DenyIfViewerOutboundEdgeToEntPropertyExistsRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private edgeType;
+    private options?;
+    constructor(property: keyof T, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
+/**
+ * This is a privacy policy rule that checks if edge exists from ent's id to viewer's id
+ * Denies the viewer from seeing the ent if the edge exists
+ */
+export declare class DenyIfEdgeExistsFromEntPropertyToViewerRule<T extends Ent> extends DenyIfViewerOutboundEdgeToEntPropertyExistsRule<T> {
+}
 export declare class DenyIfEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private id1;
     private id2;
@@ -171,6 +266,20 @@ export declare class DenyIfViewerOutboundEdgeDoesNotExistRule implements Privacy
     constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
+export declare class DenyIfViewerInboundEdgeToEntPropertyDoesNotExistRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private edgeType;
+    private options?;
+    constructor(property: keyof T, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
+export declare class DenyIfViewerOutboundEdgeToEntPropertyDoesNotExistRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private edgeType;
+    private options?;
+    constructor(property: keyof T, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
 export declare class AllowIfConditionAppliesRule implements PrivacyPolicyRule {
     private fn;
     private rule;

package/core/privacy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyImpl = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
+exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyImpl = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeToEntPropertyDoesNotExistRule = exports.DenyIfViewerInboundEdgeToEntPropertyDoesNotExistRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfEdgeExistsFromEntPropertyToViewerRule = exports.DenyIfViewerOutboundEdgeToEntPropertyExistsRule = exports.DenyIfEdgeExistsFromViewerToEntPropertyRule = exports.DenyIfViewerInboundEdgeToEntPropertyExistsRule = exports.DenyIfEdgeExistsFromEntToViewerRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfEdgeExistsFromViewerToEntRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfEdgeExistsFromEntPropertyToViewerRule = exports.AllowIfEdgeExistsFromViewerToEntPropertyRule = exports.AllowIfEdgeExistsFromEntToViewerRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfEdgeExistsFromViewerToEntRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeDoesNotExistRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
+exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = void 0;
 const types_1 = require("util/types");
 const base_1 = require("./base");
 const ent_1 = require("./ent");
@@ -278,6 +279,23 @@ async function allowIfEdgeExistsRule(id1, id2, edgeType, context, options) {
     }
     return (0, base_1.Skip)();
 }
+async function allowIfEdgeDoesNotExistRule(id1, id2, edgeType, context, options) {
+    if (!id1 || !id2) {
+        return (0, base_1.Allow)();
+    }
+    const edge = await (0, ent_1.loadEdgeForID2)({
+        id1,
+        edgeType,
+        id2,
+        context,
+        ctr: ent_1.AssocEdge,
+        queryOptions: options,
+    });
+    if (!edge) {
+        return (0, base_1.Allow)();
+    }
+    return (0, base_1.Skip)();
+}
 class AllowIfEdgeExistsRule {
     constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
@@ -290,6 +308,23 @@ class AllowIfEdgeExistsRule {
     }
 }
 exports.AllowIfEdgeExistsRule = AllowIfEdgeExistsRule;
+class AllowIfEdgeDoesNotExistRule {
+    constructor(id1, id2, edgeType, options) {
+        this.id1 = id1;
+        this.id2 = id2;
+        this.edgeType = edgeType;
+        this.options = options;
+    }
+    async apply(v, _ent) {
+        return allowIfEdgeDoesNotExistRule(this.id1, this.id2, this.edgeType, v.context, this.options);
+    }
+}
+exports.AllowIfEdgeDoesNotExistRule = AllowIfEdgeDoesNotExistRule;
+/**
+ * @deprecated use AllowIfEdgeExistsFromViewerToEntRule
+ * This is a privacy policy rule that checks if the viewer has an inbound edge to the ent.
+ * e.g. does edge exist from viewer's id to ent's id
+ */
 class AllowIfViewerInboundEdgeExistsRule {
     constructor(edgeType, options) {
         this.edgeType = edgeType;
@@ -300,6 +335,18 @@ class AllowIfViewerInboundEdgeExistsRule {
     }
 }
 exports.AllowIfViewerInboundEdgeExistsRule = AllowIfViewerInboundEdgeExistsRule;
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer's id to ent's id
+ * Allows the viewer to see the ent if the edge exists
+ */
+class AllowIfEdgeExistsFromViewerToEntRule extends AllowIfViewerInboundEdgeExistsRule {
+}
+exports.AllowIfEdgeExistsFromViewerToEntRule = AllowIfEdgeExistsFromViewerToEntRule;
+/**
+ * @deprecated use AllowIfEdgeExistsFromEntToViewerRule
+ * This is a privacy policy rule that checks if the viewer has an outbound edge to the ent.
+ * e.g. does edge exist from ent's id to viewer's id
+ */
 class AllowIfViewerOutboundEdgeExistsRule {
     constructor(edgeType, options) {
         this.edgeType = edgeType;
@@ -310,6 +357,39 @@ class AllowIfViewerOutboundEdgeExistsRule {
     }
 }
 exports.AllowIfViewerOutboundEdgeExistsRule = AllowIfViewerOutboundEdgeExistsRule;
+/**
+ * This is a privacy policy rule that checks if edge exists from ent's id to viewer's id
+ */
+class AllowIfEdgeExistsFromEntToViewerRule extends AllowIfViewerOutboundEdgeExistsRule {
+}
+exports.AllowIfEdgeExistsFromEntToViewerRule = AllowIfEdgeExistsFromEntToViewerRule;
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer to id of given ent property
+ */
+class AllowIfEdgeExistsFromViewerToEntPropertyRule {
+    constructor(property, edgeType, options) {
+        this.property = property;
+        this.edgeType = edgeType;
+        this.options = options;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        return allowIfEdgeExistsRule(v.viewerID, result, this.edgeType, v.context, this.options);
+    }
+}
+exports.AllowIfEdgeExistsFromViewerToEntPropertyRule = AllowIfEdgeExistsFromViewerToEntPropertyRule;
+class AllowIfEdgeExistsFromEntPropertyToViewerRule {
+    constructor(property, edgeType, options) {
+        this.property = property;
+        this.edgeType = edgeType;
+        this.options = options;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        return allowIfEdgeExistsRule(result, v.viewerID, this.edgeType, v.context, this.options);
+    }
+}
+exports.AllowIfEdgeExistsFromEntPropertyToViewerRule = AllowIfEdgeExistsFromEntPropertyToViewerRule;
 async function denyIfEdgeExistsRule(id1, id2, edgeType, context, options) {
     // edge doesn't exist if no viewer
     if (id1 && id2) {
@@ -357,6 +437,9 @@ class DenyIfEdgeExistsRule {
     }
 }
 exports.DenyIfEdgeExistsRule = DenyIfEdgeExistsRule;
+/**
+ * @deprecated use DenyIfEdgeExistsFromViewerToEntRule
+ */
 class DenyIfViewerInboundEdgeExistsRule {
     constructor(edgeType, options) {
         this.edgeType = edgeType;
@@ -367,6 +450,16 @@ class DenyIfViewerInboundEdgeExistsRule {
     }
 }
 exports.DenyIfViewerInboundEdgeExistsRule = DenyIfViewerInboundEdgeExistsRule;
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer's id to ent's id
+ * Denies the viewer from seeing the ent if the edge exists
+ */
+class DenyIfEdgeExistsFromViewerToEntRule extends DenyIfViewerInboundEdgeExistsRule {
+}
+exports.DenyIfEdgeExistsFromViewerToEntRule = DenyIfEdgeExistsFromViewerToEntRule;
+/**
+ * @deprecated use DenyIfEdgeExistsFromEntToViewerRule
+ */
 class DenyIfViewerOutboundEdgeExistsRule {
     constructor(edgeType, options) {
         this.edgeType = edgeType;
@@ -377,6 +470,56 @@ class DenyIfViewerOutboundEdgeExistsRule {
     }
 }
 exports.DenyIfViewerOutboundEdgeExistsRule = DenyIfViewerOutboundEdgeExistsRule;
+/**
+ * This is a privacy policy rule that checks if edge exists from ent's id to viewer's id
+ */
+class DenyIfEdgeExistsFromEntToViewerRule extends DenyIfViewerOutboundEdgeExistsRule {
+}
+exports.DenyIfEdgeExistsFromEntToViewerRule = DenyIfEdgeExistsFromEntToViewerRule;
+/**
+ * @deprecated use DenyIfEdgeExistsFromViewerToEntPropertyRule
+ */
+class DenyIfViewerInboundEdgeToEntPropertyExistsRule {
+    constructor(property, edgeType, options) {
+        this.property = property;
+        this.edgeType = edgeType;
+        this.options = options;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        return denyIfEdgeExistsRule(v.viewerID, result, this.edgeType, v.context, this.options);
+    }
+}
+exports.DenyIfViewerInboundEdgeToEntPropertyExistsRule = DenyIfViewerInboundEdgeToEntPropertyExistsRule;
+/**
+ * This is a privacy policy rule that checks if edge exists from viewer's id to ent's id
+ * Denies the viewer from seeing the ent if the edge exists
+ */
+class DenyIfEdgeExistsFromViewerToEntPropertyRule extends DenyIfViewerInboundEdgeToEntPropertyExistsRule {
+}
+exports.DenyIfEdgeExistsFromViewerToEntPropertyRule = DenyIfEdgeExistsFromViewerToEntPropertyRule;
+/**
+ * @deprecated use DenyIfEdgeExistsFromEntToViewerPropertyRule
+ */
+class DenyIfViewerOutboundEdgeToEntPropertyExistsRule {
+    constructor(property, edgeType, options) {
+        this.property = property;
+        this.edgeType = edgeType;
+        this.options = options;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        return denyIfEdgeExistsRule(result, v.viewerID, this.edgeType, v.context, this.options);
+    }
+}
+exports.DenyIfViewerOutboundEdgeToEntPropertyExistsRule = DenyIfViewerOutboundEdgeToEntPropertyExistsRule;
+/**
+ * This is a privacy policy rule that checks if edge exists from ent's id to viewer's id
+ * Denies the viewer from seeing the ent if the edge exists
+ */
+class DenyIfEdgeExistsFromEntPropertyToViewerRule extends DenyIfViewerOutboundEdgeToEntPropertyExistsRule {
+}
+exports.DenyIfEdgeExistsFromEntPropertyToViewerRule = DenyIfEdgeExistsFromEntPropertyToViewerRule;
 class DenyIfEdgeDoesNotExistRule {
     constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
@@ -409,6 +552,30 @@ class DenyIfViewerOutboundEdgeDoesNotExistRule {
     }
 }
 exports.DenyIfViewerOutboundEdgeDoesNotExistRule = DenyIfViewerOutboundEdgeDoesNotExistRule;
+class DenyIfViewerInboundEdgeToEntPropertyDoesNotExistRule {
+    constructor(property, edgeType, options) {
+        this.property = property;
+        this.edgeType = edgeType;
+        this.options = options;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        return denyIfEdgeDoesNotExistRule(v.viewerID, result, this.edgeType, v.context, this.options);
+    }
+}
+exports.DenyIfViewerInboundEdgeToEntPropertyDoesNotExistRule = DenyIfViewerInboundEdgeToEntPropertyDoesNotExistRule;
+class DenyIfViewerOutboundEdgeToEntPropertyDoesNotExistRule {
+    constructor(property, edgeType, options) {
+        this.property = property;
+        this.edgeType = edgeType;
+        this.options = options;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        return denyIfEdgeDoesNotExistRule(result, v.viewerID, this.edgeType, v.context, this.options);
+    }
+}
+exports.DenyIfViewerOutboundEdgeToEntPropertyDoesNotExistRule = DenyIfViewerOutboundEdgeToEntPropertyDoesNotExistRule;
 // need a Deny version of this too
 class AllowIfConditionAppliesRule {
     constructor(fn, rule) {

package/graphql/node_resolver.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = void 0;
+function encodeHelper(nodeType, id) {
+    return btoa(`node:${nodeType}:${id}`);
+}
 class EntNodeResolver {
     constructor(loader) {
         this.loader = loader;
     }
     encode(node) {
         // let's do 3 parts. we take the "node" prefix
-        const str = `node:${node.nodeType}:${node.id}`;
-        return Buffer.from(str, "ascii").toString("base64");
+        return encodeHelper(node.nodeType, node.id);
     }
     static decode(id) {
-        const decoded = Buffer.from(id, "base64").toString("ascii");
+        const decoded = atob(id);
         let parts = decoded.split(":");
         if (parts.length != 3) {
             return null;
@@ -19,7 +21,7 @@ class EntNodeResolver {
         return parts[2];
     }
     mustDecode(id) {
-        const decoded = Buffer.from(id, "base64").toString("ascii");
+        const decoded = atob(id);
         let parts = decoded.split(":");
         if (parts.length != 3) {
             throw new Error(`invalid id ${id} passed to EntNodeResolver`);
@@ -27,7 +29,7 @@ class EntNodeResolver {
         return [parts[0], parts[1]];
     }
     async decodeObj(viewer, id) {
-        const decoded = Buffer.from(id, "base64").toString("ascii");
+        const decoded = atob(id);
         let parts = decoded.split(":");
         if (parts.length != 3 || parts[0] != "node") {
             return null;
@@ -92,7 +94,6 @@ 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
-    const str = `node:${node.nodeType}:${node.id}`;
-    return Buffer.from(str, "ascii").toString("base64");
+    return btoa(`node:${node.nodeType}:${node.id}`);
 }
 exports.encodeGQLID = encodeGQLID;

package/package.json

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

package/schema/field.js

@@ -29,10 +29,10 @@ const types_1 = require("util/types");
 const uuid_1 = require("uuid");
 const base_1 = require("../core/base");
 const db_1 = __importStar(require("../core/db"));
-const schema_1 = require("./schema");
 const global_schema_1 = require("../core/global_schema");
 const logger_1 = require("../core/logger");
 const names_1 = require("../names/names");
+const schema_1 = require("./schema");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -495,7 +495,7 @@ class DateField extends BaseField {
         this.type = { dbType: schema_1.DBType.Date };
     }
     format(val) {
-        if (typeof val === "string") {
+        if (typeof val === "string" || val === null || val === undefined) {
             return val;
         }
         val = new Date(val);

package/schema/schema.d.ts

@@ -247,7 +247,6 @@ export interface FieldOptions {
     getDerivedFields?(name: string): FieldMap;
     convert?: ConvertType;
     fetchOnDemand?: boolean;
-    disableBase64Encode?: boolean;
     dbOnly?: boolean;
     [x: string]: any;
 }

package/schema/struct_field.js

@@ -36,8 +36,7 @@ class StructField extends field_1.BaseField {
             throw new Error("valid was not called");
         }
         let ret = {};
-        for (const k in this.options.fields) {
-            const field = this.options.fields[k];
+        const processField = (k, field) => {
             // check two values
             // store in dbKey format
             // check both fieldName and dbKey and store in dbKey for
@@ -52,7 +51,7 @@ class StructField extends field_1.BaseField {
                 val = obj[dbKey];
             }
             if (val === undefined) {
-                continue;
+                return;
             }
             if (field.format) {
                 // indicate nested so this isn't JSON stringified
@@ -61,6 +60,16 @@ class StructField extends field_1.BaseField {
             else {
                 ret[dbKey] = val;
             }
+        };
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            processField(k, field);
+            if (field.getDerivedFields) {
+                const derivedFields = field.getDerivedFields(k);
+                for (const k in derivedFields) {
+                    processField(k, derivedFields[k]);
+                }
+            }
         }
         // don't json.stringify if nested or list
         if (nested) {
@@ -114,11 +123,7 @@ class StructField extends field_1.BaseField {
             return false;
         }
         let promises = [];
-        // TODO probably need to support optional fields...
-        let valid = true;
-        for (const k in this.options.fields) {
-            const field = this.options.fields[k];
-            let dbKey = (0, schema_1.getStorageKey)(field, k);
+        const processField = (k, dbKey, field) => {
             let fieldName = (0, names_1.toFieldName)(k);
             let val = obj[fieldName];
             let uniqueKeyField = false;
@@ -145,15 +150,34 @@ class StructField extends field_1.BaseField {
             if (val === undefined || val === null) {
                 // nullable, nothing to do here
                 if (field.nullable) {
-                    continue;
+                    return;
                 }
                 valid = false;
-                break;
+                return false;
             }
             if (!field.valid) {
-                continue;
+                return;
             }
             promises.push(field.valid(val));
+        };
+        // TODO probably need to support optional fields...
+        let valid = true;
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            let dbKey = (0, schema_1.getStorageKey)(field, k);
+            if (processField(k, dbKey, field) === false) {
+                valid = false;
+            }
+            if (field.getDerivedFields) {
+                const derivedFields = field.getDerivedFields(k);
+                for (const k in derivedFields) {
+                    const derivedField = derivedFields[k];
+                    let dbKey = (0, schema_1.getStorageKey)(derivedField, k);
+                    if (processField(k, dbKey, derivedField) === false) {
+                        valid = false;
+                    }
+                }
+            }
         }
         if (!valid) {
             return valid;

package/testutils/db/temp_db.js

@@ -433,7 +433,7 @@ class TempDB {
                 db_1.default.initDB({
                     connectionString: connStr,
                     cfg: {
-                        max: 100,
+                        max: 200,
                         idleTimeoutMillis: 100,
                     },
                 });

package/tsc/compilerOptions.d.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 export declare function readCompilerOptions(filePath: string): ts.CompilerOptions;
 export declare function getTarget(target?: string): ts.ScriptTarget;
+export declare function getModule(module?: string): ts.ModuleKind;
 export declare function getTargetFromCurrentDir(): ts.ScriptTarget;
 export declare function createSourceFile(target: ts.ScriptTarget, file: string): {
     contents: string;

package/tsc/compilerOptions.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSourceFile = exports.getTargetFromCurrentDir = exports.getTarget = exports.readCompilerOptions = void 0;
+exports.createSourceFile = exports.getTargetFromCurrentDir = exports.getModule = exports.getTarget = exports.readCompilerOptions = void 0;
 const fs = __importStar(require("fs"));
 const json5_1 = __importDefault(require("json5"));
 const typescript_1 = __importDefault(require("typescript"));
@@ -60,6 +60,8 @@ function readCompilerOptions(filePath) {
     if (options.moduleResolution === "node") {
         options.moduleResolution = typescript_1.default.ModuleResolutionKind.NodeJs;
     }
+    options.target = getTarget(options.target);
+    options.module = getModule(options.module);
     return options;
 }
 exports.readCompilerOptions = readCompilerOptions;
@@ -90,6 +92,35 @@ function getTarget(target) {
     }
 }
 exports.getTarget = getTarget;
+function getModule(module) {
+    switch (module?.toLowerCase()) {
+        case "none":
+            return typescript_1.default.ModuleKind.None;
+        case "commonjs":
+            return typescript_1.default.ModuleKind.CommonJS;
+        case "amd":
+            return typescript_1.default.ModuleKind.AMD;
+        case "umd":
+            return typescript_1.default.ModuleKind.UMD;
+        case "system":
+            return typescript_1.default.ModuleKind.System;
+        case "es2015":
+            return typescript_1.default.ModuleKind.ES2015;
+        case "es2020":
+            return typescript_1.default.ModuleKind.ES2020;
+        case "es2022":
+            return typescript_1.default.ModuleKind.ES2022;
+        case "esnext":
+            return typescript_1.default.ModuleKind.ESNext;
+        case "node16":
+            return typescript_1.default.ModuleKind.Node16;
+        case "nodenext":
+            return typescript_1.default.ModuleKind.NodeNext;
+        default:
+            return typescript_1.default.ModuleKind.CommonJS;
+    }
+}
+exports.getModule = getModule;
 function getTargetFromCurrentDir() {
     const options = readCompilerOptions(".");
     return getTarget(options.target?.toString());