@abedmurrar/objection 4.0.0-beta.4 → 4.0.0-beta.6

package/lib/queryBuilder/QueryBuilderContext.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
-class QueryBuilderContext extends QueryBuilderContextBase {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderContext = void 0;
+const QueryBuilderContextBase_1 = require("./QueryBuilderContextBase");
+class QueryBuilderContext extends QueryBuilderContextBase_1.QueryBuilderContextBase {
     constructor(builder) {
         super(builder);
         this.runBefore = [];
@@ -15,6 +17,4 @@ class QueryBuilderContext extends QueryBuilderContextBase {
         return ctx;
     }
 }
-module.exports = {
-    QueryBuilderContext,
-};
+exports.QueryBuilderContext = QueryBuilderContext;

package/lib/queryBuilder/QueryBuilderContextBase.js

@@ -1,15 +1,21 @@
-'use strict';
-const { InternalOptions } = require('./InternalOptions');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderContextBase = void 0;
+const InternalOptions_1 = require("./InternalOptions");
 class QueryBuilderContextBase {
     constructor(builder) {
-        this.userContext = builder ? new builder.constructor.QueryBuilderUserContext(builder) : null;
-        this.options = builder ? new this.constructor.InternalOptions() : null;
+        // `userContext` and `options` are only null in the copy that `clone()`
+        // creates, which assigns them right away.
+        this.userContext = (builder
+            ? new builder.constructor.QueryBuilderUserContext(builder)
+            : null);
+        this.options = (builder ? new this.constructor.InternalOptions() : null);
         this.knex = null;
         this.aliasMap = null;
         this.tableMap = null;
     }
     static get InternalOptions() {
-        return InternalOptions;
+        return InternalOptions_1.InternalOptions;
     }
     clone() {
         const ctx = new this.constructor();
@@ -21,6 +27,4 @@ class QueryBuilderContextBase {
         return ctx;
     }
 }
-module.exports = {
-    QueryBuilderContextBase,
-};
+exports.QueryBuilderContextBase = QueryBuilderContextBase;

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -1,9 +1,11 @@
-'use strict';
-const { isString, isFunction, isRegExp, mergeMaps, last } = require('../utils/objectUtils');
-const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
-const { QueryBuilderUserContext } = require('./QueryBuilderUserContext');
-const { deprecate } = require('../utils/deprecate');
-const { effectiveWhereScope, createWhereGrouping } = require('./whereScopes');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderOperationSupport = void 0;
+const objectUtils_1 = require("../utils/objectUtils");
+const QueryBuilderContextBase_1 = require("./QueryBuilderContextBase");
+const QueryBuilderUserContext_1 = require("./QueryBuilderUserContext");
+const deprecate_1 = require("../utils/deprecate");
+const whereScopes_1 = require("./whereScopes");
 const AllSelector = () => true;
 const SelectSelector = /^(select|columns|column|distinct|count|countDistinct|min|max|sum|sumDistinct|avg|avgDistinct)$/;
 const WhereSelector = /^(where|orWhere|andWhere|find\w+)/;
@@ -31,10 +33,10 @@ class QueryBuilderOperationSupport {
         return AllSelector;
     }
     static get QueryBuilderContext() {
-        return QueryBuilderContextBase;
+        return QueryBuilderContextBase_1.QueryBuilderContextBase;
     }
     static get QueryBuilderUserContext() {
-        return QueryBuilderUserContext;
+        return QueryBuilderUserContext_1.QueryBuilderUserContext;
     }
     static get SelectSelector() {
         return SelectSelector;
@@ -107,7 +109,7 @@ class QueryBuilderOperationSupport {
         const tableName = getTableName(modelClassOrTableName);
         const ctx = this.internalContext();
         const tableMap = ctx.tableMap;
-        if (isString(newTableName)) {
+        if ((0, objectUtils_1.isString)(newTableName)) {
             ctx.tableMap = tableMap || new Map();
             ctx.tableMap.set(tableName, newTableName);
             return this;
@@ -120,7 +122,7 @@ class QueryBuilderOperationSupport {
         const tableName = getTableName(modelClassOrTableName);
         const ctx = this.internalContext();
         const aliasMap = ctx.aliasMap;
-        if (isString(alias)) {
+        if ((0, objectUtils_1.isString)(alias)) {
             ctx.aliasMap = aliasMap || new Map();
             ctx.aliasMap.set(tableName, alias);
             return this;
@@ -157,8 +159,8 @@ class QueryBuilderOperationSupport {
             if (this._isPartialQuery) {
                 // Merge alias and table name maps for "partial" subqueries.
                 const ctx = this.internalContext();
-                ctx.aliasMap = mergeMaps(query.internalContext().aliasMap, ctx.aliasMap);
-                ctx.tableMap = mergeMaps(query.internalContext().tableMap, ctx.tableMap);
+                ctx.aliasMap = (0, objectUtils_1.mergeMaps)(query.internalContext().aliasMap, ctx.aliasMap);
+                ctx.tableMap = (0, objectUtils_1.mergeMaps)(query.internalContext().tableMap, ctx.tableMap);
             }
             this._parentQuery = query;
             if (this.unsafeKnex() === null) {
@@ -205,6 +207,7 @@ class QueryBuilderOperationSupport {
         const operationsToReplace = [];
         const operationsToRemove = [];
         findQuery.forEachOperation((op) => op.hasToFindOperation(), (op) => {
+            // Only `QueryBuilder`s are turned into find queries.
             const findOp = op.toFindOperation(findQuery);
             if (!findOp) {
                 operationsToRemove.push(op);
@@ -242,7 +245,7 @@ class QueryBuilderOperationSupport {
         for (const op of operationsToAdd) {
             const opClone = op.clone();
             // The scope may come from a parent operation that is not copied.
-            opClone.whereScope = effectiveWhereScope(op);
+            opClone.whereScope = (0, whereScopes_1.effectiveWhereScope)(op);
             // We may be moving nested operations to the root. Clear
             // any links to the parent operations.
             opClone.parentOperation = null;
@@ -283,6 +286,7 @@ class QueryBuilderOperationSupport {
         }, false);
         return every;
     }
+    // Returns whatever the hook returns.
     callOperationMethod(operation, hookName, args) {
         try {
             operation.removeChildOperationsByHookName(hookName);
@@ -296,6 +300,7 @@ class QueryBuilderOperationSupport {
             this._activeOperations.pop();
         }
     }
+    // Returns whatever the hook returns.
     async callAsyncOperationMethod(operation, hookName, args) {
         operation.removeChildOperationsByHookName(hookName);
         this._activeOperations.push({
@@ -323,7 +328,7 @@ class QueryBuilderOperationSupport {
                 operation.whereScope = this._whereScope;
             }
             if (this._activeOperations.length) {
-                const { operation: parentOperation, hookName } = last(this._activeOperations);
+                const { operation: parentOperation, hookName } = (0, objectUtils_1.last)(this._activeOperations);
                 parentOperation.addChildOperation(hookName, operation);
             }
             else {
@@ -382,7 +387,7 @@ class QueryBuilderOperationSupport {
         });
     }
     executeOnBuildKnex(knexBuilder) {
-        const whereGrouping = createWhereGrouping(this);
+        const whereGrouping = (0, whereScopes_1.createWhereGrouping)(this);
         this.forEachOperation(true, (op) => {
             if (whereGrouping !== null && whereGrouping.isGrouped(op)) {
                 knexBuilder = whereGrouping.build(op, knexBuilder);
@@ -403,11 +408,12 @@ class QueryBuilderOperationSupport {
         return this.toString();
     }
     skipUndefined() {
-        deprecate('skipUndefined() is deprecated and will be removed in objection 4.0');
+        (0, deprecate_1.deprecate)('skipUndefined() is deprecated and will be removed in objection 4.0');
         this.internalOptions().skipUndefined = true;
         return this;
     }
 }
+exports.QueryBuilderOperationSupport = QueryBuilderOperationSupport;
 // Operation selectors are `true` (every operation), a regex or a string that
 // is matched against the operation name, an operation class, or a predicate.
 // Queries walk their operations many times, so the selector is classified
@@ -422,17 +428,18 @@ function selectorKind(operationSelector) {
     if (operationSelector === true) {
         return SELECT_ALL;
     }
-    else if (isRegExp(operationSelector)) {
+    else if ((0, objectUtils_1.isRegExp)(operationSelector)) {
         return SELECT_REGEX;
     }
-    else if (isString(operationSelector)) {
+    else if ((0, objectUtils_1.isString)(operationSelector)) {
         return SELECT_NAME;
     }
-    else if (isFunction(operationSelector) &&
-        operationSelector.isObjectionQueryBuilderOperationClass) {
+    else if ((0, objectUtils_1.isFunction)(operationSelector) &&
+        operationSelector
+            .isObjectionQueryBuilderOperationClass) {
         return SELECT_CLASS;
     }
-    else if (isFunction(operationSelector)) {
+    else if ((0, objectUtils_1.isFunction)(operationSelector)) {
         return SELECT_PREDICATE;
     }
     else {
@@ -444,6 +451,7 @@ function matchesSelector(op, kind, operationSelector) {
         case SELECT_ALL:
             return true;
         case SELECT_REGEX:
+            // A null name is tested as 'null', as `test()` converts it to a string.
             return operationSelector.test(op.name);
         case SELECT_NAME:
             return op.name === operationSelector;
@@ -472,13 +480,10 @@ function visitOperations(operations, kind, operationSelector, callback, match) {
     return true;
 }
 function getTableName(modelClassOrTableName) {
-    if (isString(modelClassOrTableName)) {
+    if ((0, objectUtils_1.isString)(modelClassOrTableName)) {
         return modelClassOrTableName;
     }
     else {
         return modelClassOrTableName.getTableName();
     }
 }
-module.exports = {
-    QueryBuilderOperationSupport,
-};

package/lib/queryBuilder/QueryBuilderUserContext.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderUserContext = void 0;
 const SYMBOL_BUILDER = Symbol();
 class QueryBuilderUserContext {
     constructor(builder) {
@@ -20,6 +22,4 @@ class QueryBuilderUserContext {
         return ctx;
     }
 }
-module.exports = {
-    QueryBuilderUserContext,
-};
+exports.QueryBuilderUserContext = QueryBuilderUserContext;

package/lib/queryBuilder/StaticHookArguments.js

@@ -1,5 +1,9 @@
-'use strict';
-const { asArray } = require('../utils/objectUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticHookArguments = void 0;
+exports.markDefaultStaticHook = markDefaultStaticHook;
+exports.hasStaticHook = hasStaticHook;
+const objectUtils_1 = require("../utils/objectUtils");
 const BUILDER_SYMBOL = Symbol();
 // The static hooks of `Model`, which do nothing. Queries skip creating the
 // arguments and calling the hook when a model class hasn't overridden it.
@@ -19,7 +23,7 @@ class StaticHookArguments {
             value: builder,
         });
         Object.defineProperty(this, 'result', {
-            value: asArray(result),
+            value: (0, objectUtils_1.asArray)(result),
         });
     }
     static create(args) {
@@ -27,7 +31,7 @@ class StaticHookArguments {
     }
     get asFindQuery() {
         return () => {
-            return this[BUILDER_SYMBOL].toFindQuery().clearWithGraphFetched().runAfter(asArray);
+            return this[BUILDER_SYMBOL].toFindQuery().clearWithGraphFetched().runAfter(objectUtils_1.asArray);
         };
     }
     get context() {
@@ -57,7 +61,7 @@ class StaticHookArguments {
     get items() {
         const op = this[BUILDER_SYMBOL].findOperation(hasItems);
         if (op) {
-            return asArray(getItems(op));
+            return (0, objectUtils_1.asArray)(getItems(op));
         }
         else {
             return [];
@@ -66,7 +70,7 @@ class StaticHookArguments {
     get inputItems() {
         const op = this[BUILDER_SYMBOL].findOperation(hasInputItems);
         if (op) {
-            return asArray(getInputItems(op));
+            return (0, objectUtils_1.asArray)(getInputItems(op));
         }
         else {
             return [];
@@ -91,6 +95,7 @@ class StaticHookArguments {
         };
     }
 }
+exports.StaticHookArguments = StaticHookArguments;
 function getRelation(op) {
     return op.relation;
 }
@@ -115,8 +120,3 @@ function getInputItems(op) {
 function hasInputItems(op) {
     return !!getInputItems(op);
 }
-module.exports = {
-    StaticHookArguments,
-    markDefaultStaticHook,
-    hasStaticHook,
-};

package/lib/queryBuilder/graph/GraphAction.js

@@ -1,5 +1,7 @@
-'use strict';
-const { isPostgres } = require('../../utils/knexUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphAction = void 0;
+const knexUtils_1 = require("../../utils/knexUtils");
 const POSTGRES_MAX_INSERT_BATCH_SIZE = 100;
 const MAX_CONCURRENCY = 100;
 class GraphAction {
@@ -9,7 +11,7 @@ class GraphAction {
     static get ReturningAllSelector() {
         return (op) => {
             // Only select `returning('*')` operation.
-            return op.name === 'returning' && op.args.includes('*');
+            return (op.name === 'returning' && op.args.includes('*'));
         };
     }
     static getConcurrency(builder, nodes) {
@@ -33,7 +35,7 @@ class GraphAction {
         return GraphAction.getConcurrency(builder, nodes);
     }
     _getBatchSize(builder) {
-        return isPostgres(builder.unsafeKnex()) ? POSTGRES_MAX_INSERT_BATCH_SIZE : 1;
+        return (0, knexUtils_1.isPostgres)(builder.unsafeKnex()) ? POSTGRES_MAX_INSERT_BATCH_SIZE : 1;
     }
     _resolveReferences(node) {
         if (node.isReference) {
@@ -49,6 +51,4 @@ class GraphAction {
         }
     }
 }
-module.exports = {
-    GraphAction,
-};
+exports.GraphAction = GraphAction;

package/lib/queryBuilder/graph/GraphData.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphData = void 0;
 class GraphData {
     constructor({ graph, currentGraph, graphOptions, nodeDbExistence }) {
         this.graph = graph;
@@ -7,6 +9,4 @@ class GraphData {
         this.nodeDbExistence = nodeDbExistence;
     }
 }
-module.exports = {
-    GraphData,
-};
+exports.GraphData = GraphData;

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -1,21 +1,23 @@
-'use strict';
-const { asArray, groupBy } = require('../../utils/objectUtils');
-const { ModelGraph } = require('../../model/graph/ModelGraph');
-const { FetchStrategy } = require('./GraphOptions');
-const { RelationExpression } = require('../RelationExpression');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphFetcher = void 0;
+const objectUtils_1 = require("../../utils/objectUtils");
+const ModelGraph_1 = require("../../model/graph/ModelGraph");
+const GraphOptions_1 = require("./GraphOptions");
+const RelationExpression_1 = require("../RelationExpression");
 class GraphFetcher {
     /**
      * Given a graph and options, fetches the current state of that graph
      * from the database and returns it as a ModelGraph instance.
      */
-    static async fetchCurrentGraph({ builder, graph, graphOptions }) {
+    static async fetchCurrentGraph({ builder, graph, graphOptions, }) {
         const { rootObjects } = graph;
         const rootIds = getRootIds(rootObjects);
         const modelClass = builder.modelClass();
         if (rootIds.length === 0) {
-            return Promise.resolve(ModelGraph.create(modelClass, []));
+            return Promise.resolve(ModelGraph_1.ModelGraph.create(modelClass, []));
         }
-        const eagerExpr = RelationExpression.fromModelGraph(rootObjects);
+        const eagerExpr = RelationExpression_1.RelationExpression.fromModelGraph(rootObjects);
         const models = await modelClass
             .query()
             .childQueryOf(builder, childQueryOptions())
@@ -24,11 +26,12 @@ class GraphFetcher {
             .findByIds(rootIds)
             .withGraphFetched(eagerExpr)
             .internalOptions(fetchQueryInternalOptions());
-        return ModelGraph.create(modelClass, models);
+        return ModelGraph_1.ModelGraph.create(modelClass, models);
     }
 }
+exports.GraphFetcher = GraphFetcher;
 function getRootIds(rootObjects) {
-    return asArray(rootObjects)
+    return (0, objectUtils_1.asArray)(rootObjects)
         .filter((it) => it.$hasId())
         .map((root) => root.$id());
 }
@@ -57,7 +60,7 @@ function buildFetchQuerySelects(graph, graphOptions, eagerExpr) {
     };
 }
 function groupNodesByRelationPath(graph, eagerExpr) {
-    const nodesByRelationPath = groupBy(graph.nodes, (node) => node.relationPathKey);
+    const nodesByRelationPath = (0, objectUtils_1.groupBy)(graph.nodes, (node) => node.relationPathKey);
     // Not all relation paths have nodes. Relations with nulls or empty arrays
     // don't have nodes, but will still need to be fetched. Add these to the
     // map as empty arrays.
@@ -69,10 +72,10 @@ function groupNodesByRelationPath(graph, eagerExpr) {
     return nodesByRelationPath;
 }
 function createFetchSelectModifier(nodes, graphOptions) {
-    if (graphOptions.isFetchStrategy(FetchStrategy.OnlyIdentifiers)) {
+    if (graphOptions.isFetchStrategy(GraphOptions_1.FetchStrategy.OnlyIdentifiers)) {
         return createIdentifierSelector();
     }
-    else if (graphOptions.isFetchStrategy(FetchStrategy.OnlyNeeded)) {
+    else if (graphOptions.isFetchStrategy(GraphOptions_1.FetchStrategy.OnlyNeeded)) {
         return createInputColumnSelector(nodes);
     }
     else {
@@ -101,7 +104,7 @@ function createInputColumnSelector(nodes) {
             }
         }
         const selectArr = Array.from(selects.values());
-        const idColumns = asArray(builder.fullIdColumn());
+        const idColumns = (0, objectUtils_1.asArray)(builder.fullIdColumn());
         for (const idColumn of idColumns) {
             if (!selectArr.includes(idColumn)) {
                 // Always select the identifers.
@@ -142,6 +145,7 @@ function fetchQueryInternalOptions() {
         keepImplicitJoinProps: true,
     };
 }
+// `eagerExprNode` is a relation expression node: `$childNames` and a property per child.
 function forEachPath(eagerExprNode, cb, path = []) {
     for (const relation of eagerExprNode.$childNames) {
         path.push(relation);
@@ -150,6 +154,3 @@ function forEachPath(eagerExprNode, cb, path = []) {
         path.pop();
     }
 }
-module.exports = {
-    GraphFetcher,
-};

package/lib/queryBuilder/graph/GraphNodeDbExistence.js

@@ -1,7 +1,42 @@
-'use strict';
-const { GraphData } = require('./GraphData');
-const { GraphAction } = require('./GraphAction');
-const promiseUtils = require('../../utils/promiseUtils');
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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.GraphNodeDbExistence = void 0;
+const GraphData_1 = require("./GraphData");
+const GraphAction_1 = require("./GraphAction");
+const promiseUtils = __importStar(require("../../utils/promiseUtils"));
 /**
  * This weird little class is responsible for checking (and maintaining information)
  * whether certain nodes exist in the database.
@@ -19,12 +54,12 @@ class GraphNodeDbExistence {
      * creates an instance of GraphNodeDbExistence that can be used to
      * synchronously check if a node exist in the database.
      */
-    static async create({ builder, graph, graphOptions, currentGraph }) {
+    static async create({ builder, graph, graphOptions, currentGraph, }) {
         if (graphOptions.isInsertOnly()) {
             // With insertGraph, we never want to do anything but inserts.
             return GraphNodeDbExistence.createEveryNodeExistsExistence();
         }
-        const graphData = new GraphData({
+        const graphData = new GraphData_1.GraphData({
             graph,
             graphOptions,
             currentGraph,
@@ -54,6 +89,7 @@ class GraphNodeDbExistence {
         return !idMap.has(node.obj.$idKey());
     }
 }
+exports.GraphNodeDbExistence = GraphNodeDbExistence;
 function createMayNotExistMap(graphData) {
     const { graph, currentGraph, graphOptions } = graphData;
     const mayNotExist = new Map();
@@ -94,11 +130,11 @@ function hasNodeById(currentGraph, nodeToFind) {
             idProps.every((idProp) => node.obj[idProp] === nodeToFind.obj[idProp]));
     });
 }
-async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes }) {
+async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes, }) {
     const dontExist = cloneExistenceMap(mayNotExist);
     const existenceCheckQueries = createExistenceCheckQueries({ builder, mayNotExist });
     const results = await promiseUtils.map(existenceCheckQueries, (builder) => builder.execute(), {
-        concurrency: GraphAction.getConcurrency(builder, mayNotExistNodes),
+        concurrency: GraphAction_1.GraphAction.getConcurrency(builder, mayNotExistNodes),
     });
     // Remove all items from the mayNotExist map that we have just proven to exist
     // by executing the existenceCheckQueries.
@@ -113,7 +149,7 @@ async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes }) {
     // Now only items that don't exist in the db are left in this map.
     return dontExist;
 }
-function createExistenceCheckQueries({ builder, mayNotExist }) {
+function createExistenceCheckQueries({ builder, mayNotExist, }) {
     const builders = [];
     for (const [modelClass, idMap] of mayNotExist.entries()) {
         const ids = Array.from(idMap.values());
@@ -141,6 +177,3 @@ function cloneExistenceMap(exixtenseMap) {
     }
     return clone;
 }
-module.exports = {
-    GraphNodeDbExistence,
-};

package/lib/queryBuilder/graph/GraphOperation.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphOperation = void 0;
 class GraphOperation {
     constructor(graphData) {
         this.graphData = graphData;
@@ -16,6 +18,4 @@ class GraphOperation {
         return [];
     }
 }
-module.exports = {
-    GraphOperation,
-};
+exports.GraphOperation = GraphOperation;

package/lib/queryBuilder/graph/GraphOptions.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchStrategy = exports.GraphOptions = void 0;
 const NO_RELATE = 'noRelate';
 const NO_UNRELATE = 'noUnrelate';
 const NO_INSERT = 'noInsert';
@@ -15,6 +17,7 @@ const FetchStrategy = {
     Everything: 'Everything',
     OnlyNeeded: 'OnlyNeeded',
 };
+exports.FetchStrategy = FetchStrategy;
 class GraphOptions {
     constructor(options) {
         if (options instanceof GraphOptions) {
@@ -147,6 +150,7 @@ class GraphOptions {
         }
     }
 }
+exports.GraphOptions = GraphOptions;
 function getCurrentNode(node, graphData) {
     if (!graphData || !node) {
         return null;
@@ -159,7 +163,3 @@ function getNode(currentNode, graph) {
     }
     return graph.nodeForNode(currentNode);
 }
-module.exports = {
-    GraphOptions,
-    FetchStrategy,
-};