@snowtop/ent 0.2.4 → 0.2.6

package/action/action.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearEdgeTypeInGroup = exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
+exports.WriteOperation = void 0;
+exports.saveBuilder = saveBuilder;
+exports.saveBuilderX = saveBuilderX;
+exports.setEdgeTypeInGroup = setEdgeTypeInGroup;
+exports.clearEdgeTypeInGroup = clearEdgeTypeInGroup;
 const base_1 = require("../core/base");
 Object.defineProperty(exports, "WriteOperation", { enumerable: true, get: function () { return base_1.WriteOperation; } });
 const ent_1 = require("../core/ent");
@@ -8,11 +12,9 @@ const logger_1 = require("../core/logger");
 async function saveBuilder(builder) {
     await saveBuilderImpl(builder, false);
 }
-exports.saveBuilder = saveBuilder;
 async function saveBuilderX(builder) {
     await saveBuilderImpl(builder, true);
 }
-exports.saveBuilderX = saveBuilderX;
 async function saveBuilderImpl(builder, throwErr) {
     let changeset;
     try {
@@ -83,7 +85,6 @@ async function setEdgeTypeInGroup(orchestrator, inputEnumValue, id1, id2, id2Nod
     }
     await Promise.all(promises);
 }
-exports.setEdgeTypeInGroup = setEdgeTypeInGroup;
 async function clearEdgeTypeInGroup(orchestrator, id1, id2, m) {
     let promises = [];
     for (const [_, edgeType] of m) {
@@ -102,4 +103,3 @@ async function clearEdgeTypeInGroup(orchestrator, id1, id2, m) {
     }
     await Promise.all(promises);
 }
-exports.clearEdgeTypeInGroup = clearEdgeTypeInGroup;

package/action/executor.d.ts

@@ -12,7 +12,7 @@ export declare class ListBasedExecutor<T extends Ent> implements Executor {
     private complexOptions?;
     private idx;
     builder?: Builder<Ent> | undefined;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, T | null> | undefined, complexOptions?: ComplexExecutorOptions | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data, Viewer> | undefined, complexOptions?: ComplexExecutorOptions | undefined);
     private lastOp;
     private createdEnt;
     private changedOps;

package/action/executor.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOperations = exports.ComplexExecutor = exports.ListBasedExecutor = void 0;
+exports.ComplexExecutor = exports.ListBasedExecutor = void 0;
+exports.executeOperations = executeOperations;
 const graph_data_structure_1 = require("graph-data-structure");
 const ent_1 = require("../core/ent");
 const db_1 = __importDefault(require("../core/db"));
@@ -122,7 +123,7 @@ class ComplexExecutor {
         this.executors = [];
         this.changedOps = new Map();
         this.builder = options?.builder;
-        let graph = (0, graph_data_structure_1.Graph)();
+        const graph = new graph_data_structure_1.Graph();
         const changesetMap = new Map();
         const impl = (c) => {
             changesetMap.set(c.placeholderID.toString(), c);
@@ -155,7 +156,7 @@ class ComplexExecutor {
         // TODO: can this logic be rewritten to not have a set yet avoid duplicates?
         let nodeOps = new Set();
         let remainOps = new Set();
-        let sorted = graph.topologicalSort(graph.nodes());
+        const sorted = (0, graph_data_structure_1.topologicalSort)(graph);
         sorted.forEach((node) => {
             let c = changesetMap.get(node);
             if (!c) {
@@ -338,7 +339,6 @@ async function executeOperations(executor, context, trackOps) {
     }
     return operations;
 }
-exports.executeOperations = executeOperations;
 function maybeChangeOp(op, complexOptions) {
     if (!op ||
         !complexOptions?.conditionalOverride ||

package/action/experimental_action.d.ts

@@ -1,10 +1,11 @@
 import { Orchestrator } from "./orchestrator";
-import { Viewer, Ent, Data } from "../core/base";
+import { Viewer, Ent, Data, Context } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
 export interface ActionOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer, TData extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     existingEnt: TExistingEnt;
     input?: TData;
     operation?: WriteOperation;
+    viewerForEntLoad?(data: Data, ctx?: Context<TViewer>): TViewer | Promise<TViewer>;
 }
 type MaybeNull<T extends Ent> = T | null;
 type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
@@ -23,10 +24,12 @@ export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewe
     builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>;
     builder: EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
     private input;
+    options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>;
     getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, import("../core/base").ID | null>>, Viewer<Ent<any> | null, import("../core/base").ID | null>>;
     getTriggers(): Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
     getObservers(): Observer<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
     getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    viewerForEntLoad(data: Data, context?: Context<TViewer> | undefined): TViewer | Promise<TViewer>;
     constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>);
     static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>): Builder<TEnt>;
     /**
@@ -44,7 +47,7 @@ export interface BuilderConstructor<TEnt extends Ent<TViewer>, TViewer extends V
     new (viewer: TViewer, operation: WriteOperation, action: Action<TEnt, any, TViewer, TInput, TExistingEnt>, existingEnt: TExistingEnt): EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
 }
 export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
-export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
-export declare function getSimpleDeleteAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
-export declare function getSimpleInsertAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, null>, input: TInput): BaseAction<TEnt, TViewer, TInput, null>;
+export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput, opts?: Omit<ActionOptions<TEnt, TViewer, TInput, TEnt>, "operation" | "input" | "existingEnt">): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleDeleteAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput, opts?: Omit<ActionOptions<TEnt, TViewer, TInput, null>, "operation" | "input" | "existingEnt">): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleInsertAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, null>, input: TInput, opts?: Omit<ActionOptions<TEnt, TViewer, TInput, null>, "operation" | "input" | "existingEnt">): BaseAction<TEnt, TViewer, TInput, null>;
 export {};

package/action/experimental_action.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleInsertAction = exports.getSimpleDeleteAction = exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
+exports.BaseAction = void 0;
+exports.updateRawObject = updateRawObject;
+exports.getSimpleEditAction = getSimpleEditAction;
+exports.getSimpleDeleteAction = getSimpleDeleteAction;
+exports.getSimpleInsertAction = getSimpleInsertAction;
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
@@ -16,6 +20,12 @@ class BaseAction {
     getValidators() {
         return [];
     }
+    viewerForEntLoad(data, context) {
+        if (this.options.viewerForEntLoad) {
+            return this.options.viewerForEntLoad(data, context);
+        }
+        return this.viewer;
+    }
     constructor(viewer, builderCtr, options) {
         this.viewer = viewer;
         this.builderCtr = builderCtr;
@@ -30,6 +40,7 @@ class BaseAction {
         }
         this.input = options?.input || {};
         this.builder = new builderCtr(viewer, operation, this, options.existingEnt);
+        this.options = options;
     }
     static createBuilder(viewer, builderCtr, options) {
         let action = new BaseAction(viewer, builderCtr, options);
@@ -87,33 +98,32 @@ async function updateRawObject(viewer, builderCtr, existingEnt, input) {
     });
     return action.saveX();
 }
-exports.updateRawObject = updateRawObject;
 // TODO need to fix types for all these
 // creates an action which has no privacy, triggers, observers etc
 // does do field validation
 // useful to batch a bunch of writes together with BaseAction.bulkAction
 // note that only editable fields in the builder can be passed here
-function getSimpleEditAction(viewer, builderCtr, existingEnt, input) {
+function getSimpleEditAction(viewer, builderCtr, existingEnt, input, opts) {
     return new BaseAction(viewer, builderCtr, {
         existingEnt: existingEnt,
         operation: action_1.WriteOperation.Edit,
         input,
+        ...opts,
     });
 }
-exports.getSimpleEditAction = getSimpleEditAction;
-function getSimpleDeleteAction(viewer, builderCtr, existingEnt, input) {
+function getSimpleDeleteAction(viewer, builderCtr, existingEnt, input, opts) {
     return new BaseAction(viewer, builderCtr, {
         existingEnt: existingEnt,
         operation: action_1.WriteOperation.Delete,
         input,
+        ...opts,
     });
 }
-exports.getSimpleDeleteAction = getSimpleDeleteAction;
-function getSimpleInsertAction(viewer, builderCtr, input) {
+function getSimpleInsertAction(viewer, builderCtr, input, opts) {
     return new BaseAction(viewer, builderCtr, {
         operation: action_1.WriteOperation.Insert,
         input,
         existingEnt: null,
+        ...opts,
     });
 }
-exports.getSimpleInsertAction = getSimpleInsertAction;

package/action/operations.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConditionalNodeOperation = exports.ConditionalOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.NoOperation = exports.RawQueryOperation = exports.DeleteNodeOperation = void 0;
 const action_1 = require("../action");

package/action/orchestrator.d.ts

@@ -73,6 +73,14 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private getSQLStatementOperation;
     private getWriteOpForSQLStamentOp;
     getPossibleUnsafeEntForPrivacy(): Promise<TEnt>;
+    /**
+     * This gets the fields that were explicitly set plus any default or transformed values
+     * mainly exists to get default fields e.g. default id to be used in triggers
+     * NOTE: this API may change in the future
+     * doesn't work to get ids for autoincrement keys
+     * PS contrasted with getValidatedFields() which returns the format that would be written to the db
+     * i.e. includes lists which have been converted to JSON strings, etc
+     */
     getEditedData(): Promise<Data>;
     /**
      * @returns validated and formatted fields that would be written to the db
@@ -114,11 +122,11 @@ export declare class EntChangeset<TEnt extends Ent<TViewer>, TViewer extends Vie
     readonly placeholderID: ID;
     private conditionalOverride;
     operations: DataOperation<any, TViewer>[];
-    dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined;
+    dependencies?: Map<ID, Builder<Ent>> | undefined;
     changesets?: Changeset[] | undefined;
     private options?;
     private _executor;
-    constructor(viewer: Viewer, builder: Builder<TEnt, TViewer>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation<any, TViewer>[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<TEnt, Data, TViewer, MaybeNull<TEnt>> | undefined);
+    constructor(viewer: Viewer, builder: Builder<TEnt, TViewer>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation<any, TViewer>[], dependencies?: Map<ID, Builder<Ent>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<TEnt, Data, TViewer> | undefined);
     static changesetFrom<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, ops: DataOperation<any, TViewer>[]): EntChangeset<any, TViewer>;
     static changesetFromQueries<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any, TViewer>;
     private static changesetFromEdgeOp;

package/action/orchestrator.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -93,6 +103,7 @@ class Orchestrator {
         this.edgeSet = new Set();
         this.edges = new Map();
         this.conditionalEdges = new Map();
+        this.validatedFields = null;
         this.changesets = [];
         this.dependencies = new Map();
         this.fieldsToResolve = [];
@@ -401,10 +412,14 @@ class Orchestrator {
         const { schemaFields, editedData } = await this.memoizedGetFields();
         return this.getEntForPrivacyPolicyImpl(schemaFields, editedData, this.options.viewer);
     }
-    // this gets the fields that were explicitly set plus any default or transformed values
-    // mainly exists to get default fields e.g. default id to be used in triggers
-    // NOTE: this API may change in the future
-    // doesn't work to get ids for autoincrement keys
+    /**
+     * This gets the fields that were explicitly set plus any default or transformed values
+     * mainly exists to get default fields e.g. default id to be used in triggers
+     * NOTE: this API may change in the future
+     * doesn't work to get ids for autoincrement keys
+     * PS contrasted with getValidatedFields() which returns the format that would be written to the db
+     * i.e. includes lists which have been converted to JSON strings, etc
+     */
     async getEditedData() {
         const { editedData } = await this.memoizedGetFields();
         return editedData;
@@ -519,7 +534,7 @@ class Orchestrator {
         return errors;
     }
     async triggers(action, builder, triggers) {
-        let groups = [];
+        const groups = [];
         let lastArray = 0;
         let prevWasArray = false;
         for (let i = 0; i < triggers.length; i++) {
@@ -696,29 +711,12 @@ class Orchestrator {
                 data[dbKey] = value;
             }
             if (defaultValue !== undefined) {
-                // Format defaults early so JSON/list defaults are DB-ready in edited data.
-                let formattedDefaultValue = defaultValue;
-                if (defaultValue !== null && !this.isBuilder(defaultValue) && field.format) {
-                    let valid = true;
-                    if (field.valid) {
-                        valid = field.valid(defaultValue);
-                        if ((0, types_1.isPromise)(valid)) {
-                            valid = await valid;
-                        }
-                    }
-                    if (valid) {
-                        formattedDefaultValue = field.format(defaultValue);
-                        if ((0, types_1.isPromise)(formattedDefaultValue)) {
-                            formattedDefaultValue = await formattedDefaultValue;
-                        }
-                    }
-                }
                 updateInput = true;
                 if (updateOnlyIfOther) {
-                    defaultData[dbKey] = formattedDefaultValue;
+                    defaultData[dbKey] = defaultValue;
                 }
                 else {
-                    data[dbKey] = formattedDefaultValue;
+                    data[dbKey] = defaultValue;
                 }
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
                 this.defaultFieldsByTSName[this.getInputKey(fieldName)] = defaultValue;

package/action/privacy.d.ts

@@ -2,11 +2,11 @@ import { Builder } from "./action";
 import { Viewer, ID, Ent, PrivacyResult, PrivacyPolicyRule } from "../core/base";
 export declare class DenyIfBuilder implements PrivacyPolicyRule {
     private id?;
-    constructor(id?: ID | Builder<Ent<Viewer<Ent<any> | null, ID | null>>, any, Ent<Viewer<Ent<any> | null, ID | null>> | null> | undefined);
+    constructor(id?: (ID | Builder<Ent, any>) | undefined);
     apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfBuilder implements PrivacyPolicyRule {
     private id?;
-    constructor(id?: ID | Builder<Ent<Viewer<Ent<any> | null, ID | null>>, any, Ent<Viewer<Ent<any> | null, ID | null>> | null> | undefined);
+    constructor(id?: (ID | Builder<Ent, any>) | undefined);
     apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult>;
 }

package/action/relative_value.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeConvertRelativeInputPlusExpressions = exports.convertRelativeInput = exports.NumberOps = void 0;
+exports.NumberOps = void 0;
+exports.convertRelativeInput = convertRelativeInput;
+exports.maybeConvertRelativeInputPlusExpressions = maybeConvertRelativeInputPlusExpressions;
 const clause_1 = require("../core/clause");
 function addNumber(delta) {
     return {
@@ -101,7 +103,6 @@ function convertRelativeInput(rel, col, existing) {
     }
     throw new Error(`error in convertRelativeInput. shouldn't have gotten here`);
 }
-exports.convertRelativeInput = convertRelativeInput;
 function maybeConvertRelativeInputPlusExpressions(rel, col, existing, expressions) {
     if (rel === null) {
         return rel;
@@ -122,4 +123,3 @@ function maybeConvertRelativeInputPlusExpressions(rel, col, existing, expression
     expressions.set(col, clause);
     return value;
 }
-exports.maybeConvertRelativeInputPlusExpressions = maybeConvertRelativeInputPlusExpressions;

package/auth/auth.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Viewer } from "../core/base";
 import { RequestContext } from "../core/context";
 import { IncomingMessage, ServerResponse } from "http";

package/auth/auth.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildContext = exports.getLoggedInViewer = exports.clearAuthHandlers = exports.registerAuthHandler = void 0;
+exports.registerAuthHandler = registerAuthHandler;
+exports.clearAuthHandlers = clearAuthHandlers;
+exports.getLoggedInViewer = getLoggedInViewer;
+exports.buildContext = buildContext;
 const viewer_1 = require("../core/viewer");
 const context_1 = require("../core/context");
 const logger_1 = require("../core/logger");
@@ -8,11 +11,9 @@ let handlers = new Map();
 async function registerAuthHandler(name, auth) {
     handlers.set(name, auth);
 }
-exports.registerAuthHandler = registerAuthHandler;
 async function clearAuthHandlers() {
     handlers.clear();
 }
-exports.clearAuthHandlers = clearAuthHandlers;
 async function getLoggedInViewer(context) {
     for (const [name, authHandler] of handlers) {
         let v = await authHandler.authViewer(context);
@@ -24,7 +25,6 @@ async function getLoggedInViewer(context) {
     (0, logger_1.log)("info", "no auth handler returned viewer. default to logged out viewer");
     return null;
 }
-exports.getLoggedInViewer = getLoggedInViewer;
 async function buildContext(request, response) {
     const ctx = new contextImpl(request, response);
     let viewer = await getLoggedInViewer(ctx);
@@ -34,7 +34,6 @@ async function buildContext(request, response) {
     }
     return ctx;
 }
-exports.buildContext = buildContext;
 class contextImpl {
     constructor(request, response) {
         this.request = request;

package/core/base.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WriteOperation = exports.DenyWithReason = exports.Deny = exports.Skip = exports.Allow = void 0;
+exports.WriteOperation = void 0;
+exports.Allow = Allow;
+exports.Skip = Skip;
+exports.Deny = Deny;
+exports.DenyWithReason = DenyWithReason;
 // Privacy
 var privacyResult;
 (function (privacyResult) {
@@ -15,21 +19,18 @@ const allow = {
 function Allow() {
     return allow;
 }
-exports.Allow = Allow;
 const skip = {
     result: privacyResult.Skip,
 };
 function Skip() {
     return skip;
 }
-exports.Skip = Skip;
 const deny = {
     result: privacyResult.Deny,
 };
 function Deny() {
     return deny;
 }
-exports.Deny = Deny;
 class DenyWithReasonError extends Error {
     constructor(privacyPolicy, rule, msg, ent) {
         super(msg);
@@ -52,7 +53,6 @@ function DenyWithReason(e) {
         error: e,
     };
 }
-exports.DenyWithReason = DenyWithReason;
 var WriteOperation;
 (function (WriteOperation) {
     WriteOperation["Insert"] = "insert";