@snowtop/ent 0.1.0-alpha138 → 0.1.0-alpha139

package/core/ent.js

@@ -26,15 +26,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.EditNodeOperation = exports.RawQueryOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = void 0;
-exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const clause = __importStar(require("./clause"));
-const action_1 = require("../action");
 const logger_1 = require("./logger");
 const dataloader_1 = __importDefault(require("dataloader"));
-const schema_1 = require("../schema/schema");
 const global_schema_1 = require("./global_schema");
 // TODO kill this and createDataLoader
 class cacheMap {
@@ -661,489 +658,6 @@ function buildGroupQuery(options) {
     ];
 }
 exports.buildGroupQuery = buildGroupQuery;
-class RawQueryOperation {
-    constructor(queries) {
-        this.queries = queries;
-    }
-    async performWrite(queryer, context) {
-        for (const q of this.queries) {
-            if (typeof q === "string") {
-                logQuery(q, []);
-                await queryer.query(q);
-            }
-            else {
-                logQuery(q.query, q.logValues || []);
-                await queryer.query(q.query, q.values);
-            }
-        }
-    }
-    performWriteSync(queryer, context) {
-        for (const q of this.queries) {
-            if (typeof q === "string") {
-                logQuery(q, []);
-                queryer.execSync(q);
-            }
-            else {
-                logQuery(q.query, q.logValues || []);
-                queryer.execSync(q.query, q.values);
-            }
-        }
-    }
-}
-exports.RawQueryOperation = RawQueryOperation;
-class EditNodeOperation {
-    constructor(options, existingEnt = null) {
-        this.options = options;
-        this.existingEnt = existingEnt;
-        this.row = null;
-        this.placeholderID = options.placeholderID;
-    }
-    resolve(executor) {
-        if (!this.options.fieldsToResolve.length) {
-            return;
-        }
-        let fields = this.options.fields;
-        this.options.fieldsToResolve.forEach((fieldName) => {
-            let value = fields[fieldName];
-            if (!value) {
-                throw new Error(`trying to resolve field ${fieldName} but not a valid field`);
-            }
-            let ent = executor.resolveValue(value.placeholderID);
-            if (!ent) {
-                throw new Error(`couldn't resolve field \`${fieldName}\` with value ${value.placeholderID}`);
-            }
-            fields[fieldName] = ent.id;
-        });
-        this.options.fields = fields;
-    }
-    hasData(data) {
-        for (const _k in data) {
-            return true;
-        }
-        return false;
-    }
-    async performWrite(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        if (this.existingEnt) {
-            if (this.hasData(options.fields)) {
-                // even this with returning * may not always work if transformed...
-                // we can have a transformed flag to see if it should be returned?
-                this.row = await editRow(queryer, options, "RETURNING *");
-            }
-            else {
-                // @ts-ignore
-                this.row = this.existingEnt["data"];
-            }
-        }
-        else {
-            this.row = await createRow(queryer, options, "RETURNING *");
-        }
-    }
-    reloadRow(queryer, id, options) {
-        // TODO this isn't always an ObjectLoader. should throw or figure out a way to get query
-        // and run this on its own...
-        const loader = this.options.loadEntOptions.loaderFactory.createLoader(options.context);
-        const opts = loader.getOptions();
-        let cls = clause.Eq(options.key, id);
-        if (opts.clause) {
-            let optionClause;
-            if (typeof opts.clause === "function") {
-                optionClause = opts.clause();
-            }
-            else {
-                optionClause = opts.clause;
-            }
-            if (optionClause) {
-                // @ts-expect-error ID|string mismatch
-                cls = clause.And(cls, optionClause);
-            }
-        }
-        const query = buildQuery({
-            fields: opts.fields.length ? opts.fields : ["*"],
-            tableName: options.tableName,
-            clause: cls,
-        });
-        // special case log here because we're not going through any of the normal
-        // methods here because those are async and this is sync
-        // this is the only place we're doing this so only handling here
-        logQuery(query, [id]);
-        const r = queryer.querySync(query, [id]);
-        if (r.rows.length === 1) {
-            this.row = r.rows[0];
-        }
-    }
-    performWriteSync(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        if (this.existingEnt) {
-            if (this.hasData(this.options.fields)) {
-                editRowSync(queryer, options, "RETURNING *");
-                this.reloadRow(queryer, this.existingEnt.id, options);
-            }
-            else {
-                // @ts-ignore
-                this.row = this.existingEnt["data"];
-            }
-        }
-        else {
-            createRowSync(queryer, options, "RETURNING *");
-            const id = options.fields[options.key];
-            this.reloadRow(queryer, id, options);
-        }
-    }
-    returnedRow() {
-        return this.row;
-    }
-    createdEnt(viewer) {
-        if (!this.row) {
-            return null;
-        }
-        return new this.options.loadEntOptions.ent(viewer, this.row);
-    }
-}
-exports.EditNodeOperation = EditNodeOperation;
-class EdgeOperation {
-    constructor(builder, edgeInput, options) {
-        this.builder = builder;
-        this.edgeInput = edgeInput;
-        this.options = options;
-    }
-    async preFetch(queryer, context) {
-        let edgeData = await loadEdgeData(this.edgeInput.edgeType);
-        if (!edgeData) {
-            throw new Error(`error loading edge data for ${this.edgeInput.edgeType}`);
-        }
-        this.edgeData = edgeData;
-    }
-    async performWrite(queryer, context) {
-        if (!this.edgeData) {
-            throw new Error(`error fetching edgeData for type ${this.edgeInput.edgeType}`);
-        }
-        switch (this.options.operation) {
-            case action_1.WriteOperation.Delete:
-                return this.performDeleteWrite(queryer, this.edgeData, this.edgeInput, context);
-            case action_1.WriteOperation.Insert:
-            case action_1.WriteOperation.Edit:
-                return this.performInsertWrite(queryer, this.edgeData, this.edgeInput, context);
-        }
-    }
-    performWriteSync(queryer, context) {
-        if (!this.edgeData) {
-            throw new Error(`error fetching edgeData for type ${this.edgeInput.edgeType}`);
-        }
-        switch (this.options.operation) {
-            case action_1.WriteOperation.Delete:
-                return this.performDeleteWriteSync(queryer, this.edgeData, this.edgeInput, context);
-            case action_1.WriteOperation.Insert:
-            case action_1.WriteOperation.Edit:
-                return this.performInsertWriteSync(queryer, this.edgeData, this.edgeInput, context);
-        }
-    }
-    getDeleteRowParams(edgeData, edge, context) {
-        let transformed = null;
-        let op = schema_1.SQLStatementOperation.Delete;
-        let updateData = null;
-        // TODO respect disableTransformations
-        const transformedEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
-        if (transformedEdgeWrite) {
-            transformed = transformedEdgeWrite({
-                op: schema_1.SQLStatementOperation.Delete,
-                edge,
-            });
-            if (transformed) {
-                op = transformed.op;
-                if (transformed.op === schema_1.SQLStatementOperation.Insert) {
-                    throw new Error(`cannot currently transform a delete into an insert`);
-                }
-                if (transformed.op === schema_1.SQLStatementOperation.Update) {
-                    if (!transformed.data) {
-                        throw new Error(`cannot transform a delete into an update without providing data`);
-                    }
-                    updateData = transformed.data;
-                }
-            }
-        }
-        return {
-            op,
-            updateData,
-            options: {
-                tableName: edgeData.edgeTable,
-                context,
-            },
-            clause: clause.And(clause.Eq("id1", edge.id1), clause.Eq("id2", edge.id2), clause.Eq("edge_type", edge.edgeType)),
-        };
-    }
-    async performDeleteWrite(q, edgeData, edge, context) {
-        const params = this.getDeleteRowParams(edgeData, edge, context);
-        if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return deleteRows(q, params.options, params.clause);
-        }
-        else {
-            if (params.op !== schema_1.SQLStatementOperation.Update) {
-                throw new Error(`invalid operation ${params.op}`);
-            }
-            await editRow(q, {
-                tableName: params.options.tableName,
-                whereClause: params.clause,
-                fields: params.updateData,
-                fieldsToLog: params.updateData,
-            });
-        }
-    }
-    performDeleteWriteSync(q, edgeData, edge, context) {
-        const params = this.getDeleteRowParams(edgeData, edge, context);
-        if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return deleteRowsSync(q, params.options, params.clause);
-        }
-        else {
-            if (params.op !== schema_1.SQLStatementOperation.Update) {
-                throw new Error(`invalid operation ${params.op}`);
-            }
-            editRowSync(q, {
-                tableName: params.options.tableName,
-                whereClause: params.clause,
-                fields: params.updateData,
-            });
-        }
-    }
-    getInsertRowParams(edgeData, edge, context) {
-        const fields = {
-            id1: edge.id1,
-            id2: edge.id2,
-            id1_type: edge.id1Type,
-            id2_type: edge.id2Type,
-            edge_type: edge.edgeType,
-            data: edge.data || null,
-        };
-        if (edge.time) {
-            fields["time"] = edge.time.toISOString();
-        }
-        else {
-            // todo make this a schema field like what we do in generated base files...
-            // maybe when actions exist?
-            fields["time"] = new Date().toISOString();
-        }
-        const onConflictFields = ["data"];
-        const extraEdgeFields = (0, global_schema_1.__getGlobalSchema)()?.extraEdgeFields;
-        if (extraEdgeFields) {
-            for (const name in extraEdgeFields) {
-                const f = extraEdgeFields[name];
-                if (f.defaultValueOnCreate) {
-                    const storageKey = (0, schema_1.getStorageKey)(f, name);
-                    fields[storageKey] = f.defaultValueOnCreate(this.builder, {});
-                    // onconflict make sure we override the default values
-                    // e.g. setting deleted_at = null for soft delete
-                    onConflictFields.push(storageKey);
-                }
-            }
-        }
-        // TODO respect disableTransformations
-        let transformed = null;
-        const transformEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
-        if (transformEdgeWrite) {
-            transformed = transformEdgeWrite({
-                op: schema_1.SQLStatementOperation.Insert,
-                edge,
-            });
-            if (transformed) {
-                throw new Error(`transforming an insert edge not currently supported`);
-            }
-        }
-        return [
-            {
-                tableName: edgeData.edgeTable,
-                fields: fields,
-                fieldsToLog: fields,
-                context,
-            },
-            `ON CONFLICT(id1, edge_type, id2) DO UPDATE SET ${onConflictFields
-                .map((f) => `${f} = EXCLUDED.${f}`)
-                .join(", ")}`,
-        ];
-    }
-    async performInsertWrite(q, edgeData, edge, context) {
-        const [options, suffix] = this.getInsertRowParams(edgeData, edge, context);
-        await createRow(q, options, suffix);
-    }
-    performInsertWriteSync(q, edgeData, edge, context) {
-        const [options, suffix] = this.getInsertRowParams(edgeData, edge, context);
-        createRowSync(q, options, suffix);
-    }
-    resolveImpl(executor, placeholder, desc) {
-        let ent = executor.resolveValue(placeholder);
-        if (!ent) {
-            throw new Error(`could not resolve placeholder value ${placeholder} for ${desc} for edge ${this.edgeInput.edgeType}`);
-        }
-        if (ent.id === undefined) {
-            throw new Error(`id of resolved ent is not defined`);
-        }
-        return [ent.id, ent.nodeType];
-    }
-    resolve(executor) {
-        if (this.options.id1Placeholder) {
-            [this.edgeInput.id1, this.edgeInput.id1Type] = this.resolveImpl(executor, this.edgeInput.id1, "id1");
-        }
-        if (this.options.id2Placeholder) {
-            [this.edgeInput.id2, this.edgeInput.id2Type] = this.resolveImpl(executor, this.edgeInput.id2, "id2");
-        }
-        if (this.options.dataPlaceholder) {
-            if (!this.edgeInput.data) {
-                throw new Error(`data placeholder set but edgeInput data undefined`);
-            }
-            let [data, _] = this.resolveImpl(executor, this.edgeInput.data.toString(), "data");
-            this.edgeInput.data = data.toString();
-        }
-    }
-    symmetricEdge() {
-        return new EdgeOperation(this.builder, {
-            id1: this.edgeInput.id2,
-            id1Type: this.edgeInput.id2Type,
-            id2: this.edgeInput.id1,
-            id2Type: this.edgeInput.id1Type,
-            edgeType: this.edgeInput.edgeType,
-            time: this.edgeInput.time,
-            data: this.edgeInput.data,
-        }, {
-            operation: this.options.operation,
-            id1Placeholder: this.options.id2Placeholder,
-            id2Placeholder: this.options.id1Placeholder,
-            dataPlaceholder: this.options.dataPlaceholder,
-        });
-    }
-    inverseEdge(edgeData) {
-        return new EdgeOperation(this.builder, {
-            id1: this.edgeInput.id2,
-            id1Type: this.edgeInput.id2Type,
-            id2: this.edgeInput.id1,
-            id2Type: this.edgeInput.id1Type,
-            edgeType: edgeData.inverseEdgeType,
-            time: this.edgeInput.time,
-            data: this.edgeInput.data,
-        }, {
-            operation: this.options.operation,
-            id1Placeholder: this.options.id2Placeholder,
-            id2Placeholder: this.options.id1Placeholder,
-            dataPlaceholder: this.options.dataPlaceholder,
-        });
-    }
-    static resolveIDs(srcBuilder, // id1
-    destID) {
-        let destIDVal;
-        let destPlaceholder = false;
-        if (this.isBuilder(destID)) {
-            destIDVal = destID.placeholderID;
-            destPlaceholder = true;
-        }
-        else {
-            destIDVal = destID;
-        }
-        let srcIDVal;
-        let srcType;
-        let srcPlaceholder = false;
-        if (srcBuilder.existingEnt) {
-            srcIDVal = srcBuilder.existingEnt.id;
-            srcType = srcBuilder.existingEnt.nodeType;
-        }
-        else {
-            srcPlaceholder = true;
-            // get placeholder.
-            srcIDVal = srcBuilder.placeholderID;
-            // expected to be filled later
-            srcType = "";
-        }
-        return [srcIDVal, srcType, srcPlaceholder, destIDVal, destPlaceholder];
-    }
-    static isBuilder(val) {
-        return val.placeholderID !== undefined;
-    }
-    static resolveData(data) {
-        if (!data) {
-            return [undefined, false];
-        }
-        if (this.isBuilder(data)) {
-            return [data.placeholderID.toString(), true];
-        }
-        return [data, false];
-    }
-    static inboundEdge(builder, edgeType, id1, nodeType, options) {
-        let [id2Val, id2Type, id2Placeholder, id1Val, id1Placeholder] = EdgeOperation.resolveIDs(builder, id1);
-        let [data, dataPlaceholder] = EdgeOperation.resolveData(options?.data);
-        const edge = {
-            id1: id1Val,
-            edgeType: edgeType,
-            id2: id2Val,
-            id2Type: id2Type,
-            id1Type: nodeType,
-            ...options,
-        };
-        if (data) {
-            edge.data = data;
-        }
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Insert,
-            id2Placeholder,
-            id1Placeholder,
-            dataPlaceholder,
-        });
-    }
-    static outboundEdge(builder, edgeType, id2, nodeType, options) {
-        let [id1Val, id1Type, id1Placeholder, id2Val, id2Placeholder] = EdgeOperation.resolveIDs(builder, id2);
-        let [data, dataPlaceholder] = EdgeOperation.resolveData(options?.data);
-        const edge = {
-            id1: id1Val,
-            edgeType: edgeType,
-            id2: id2Val,
-            id2Type: nodeType,
-            id1Type: id1Type,
-            ...options,
-        };
-        if (data) {
-            edge.data = data;
-        }
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Insert,
-            id1Placeholder,
-            id2Placeholder,
-            dataPlaceholder,
-        });
-    }
-    static removeInboundEdge(builder, edgeType, id1) {
-        if (!builder.existingEnt) {
-            throw new Error("cannot remove an edge from a non-existing ent");
-        }
-        const edge = {
-            id1: id1,
-            edgeType: edgeType,
-            id2: builder.existingEnt.id,
-            id2Type: "",
-            id1Type: "",
-        };
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Delete,
-        });
-    }
-    static removeOutboundEdge(builder, edgeType, id2) {
-        if (!builder.existingEnt) {
-            throw new Error("cannot remove an edge from a non-existing ent");
-        }
-        const edge = {
-            id2: id2,
-            edgeType: edgeType,
-            id1: builder.existingEnt.id,
-            id2Type: "",
-            id1Type: "",
-        };
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Delete,
-        });
-    }
-}
-exports.EdgeOperation = EdgeOperation;
 function isSyncQueryer(queryer) {
     return queryer.execSync !== undefined;
 }
@@ -1213,8 +727,26 @@ function buildInsertQuery(options, suffix) {
     const cols = fields.join(", ");
     const vals = valsString.join(", ");
     let query = `INSERT INTO ${options.tableName} (${cols}) VALUES (${vals})`;
+    if (options.onConflict) {
+        let onConflict = "";
+        if (options.onConflict.onConflictConstraint) {
+            onConflict = `ON CONFLICT ON CONSTRAINT ${options.onConflict.onConflictConstraint}`;
+        }
+        else {
+            onConflict = `ON CONFLICT(${options.onConflict.onConflictCols.join(", ")})`;
+        }
+        if (options.onConflict.updateCols?.length) {
+            onConflict += ` DO UPDATE SET ${options.onConflict.updateCols
+                .map((f) => `${f} = EXCLUDED.${f}`)
+                .join(", ")}`;
+        }
+        else {
+            onConflict += ` DO NOTHING`;
+        }
+        query = query + " " + onConflict;
+    }
     if (suffix) {
-        query = query + " " + suffix;
+        query += " " + suffix;
     }
     return [query, values, logValues];
 }
@@ -1321,27 +853,6 @@ function deleteRowsSync(queryer, options, cls) {
     mutateRowSync(queryer, query, cls.values(), cls.logValues(), options);
 }
 exports.deleteRowsSync = deleteRowsSync;
-class DeleteNodeOperation {
-    constructor(id, options) {
-        this.id = id;
-        this.options = options;
-    }
-    async performWrite(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        return deleteRows(queryer, options, clause.Eq("id", this.id));
-    }
-    performWriteSync(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        return deleteRowsSync(queryer, options, clause.Eq("id", this.id));
-    }
-}
-exports.DeleteNodeOperation = DeleteNodeOperation;
 class AssocEdge {
     constructor(data) {
         this.id1 = data.id1;

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./core/base";
-export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdge, AssocEdgeInputOptions, AssocEdgeInput, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, } from "./core/ent";
+export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, AssocEdge, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, } from "./core/ent";
+export { DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdgeInputOptions, AssocEdgeInput, } from "./action/operations";
 export { setGlobalSchema } from "./core/global_schema";
 import DB from "./core/db";
 export * from "./core/loaders";

package/index.js

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.setGlobalSchema = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.DeleteNodeOperation = exports.EdgeOperation = exports.RawQueryOperation = exports.EditNodeOperation = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomCount = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
+exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.setGlobalSchema = exports.DeleteNodeOperation = exports.EdgeOperation = exports.RawQueryOperation = exports.EditNodeOperation = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomCount = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
 exports.setLogLevels = exports.loadConfig = exports.LoggedOutViewer = exports.IDViewer = exports.ContextCache = exports.query = exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.AllowIfConditionAppliesRule = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.DelayedResultRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = void 0;
 __exportStar(require("./core/base"), exports);
 var ent_1 = require("./core/ent");
@@ -48,10 +48,6 @@ Object.defineProperty(exports, "performRawQuery", { enumerable: true, get: funct
 Object.defineProperty(exports, "loadRowX", { enumerable: true, get: function () { return ent_1.loadRowX; } });
 Object.defineProperty(exports, "loadRow", { enumerable: true, get: function () { return ent_1.loadRow; } });
 Object.defineProperty(exports, "loadRows", { enumerable: true, get: function () { return ent_1.loadRows; } });
-Object.defineProperty(exports, "EditNodeOperation", { enumerable: true, get: function () { return ent_1.EditNodeOperation; } });
-Object.defineProperty(exports, "RawQueryOperation", { enumerable: true, get: function () { return ent_1.RawQueryOperation; } });
-Object.defineProperty(exports, "EdgeOperation", { enumerable: true, get: function () { return ent_1.EdgeOperation; } });
-Object.defineProperty(exports, "DeleteNodeOperation", { enumerable: true, get: function () { return ent_1.DeleteNodeOperation; } });
 Object.defineProperty(exports, "AssocEdge", { enumerable: true, get: function () { return ent_1.AssocEdge; } });
 Object.defineProperty(exports, "AssocEdgeData", { enumerable: true, get: function () { return ent_1.AssocEdgeData; } });
 Object.defineProperty(exports, "loadEdgeData", { enumerable: true, get: function () { return ent_1.loadEdgeData; } });
@@ -63,6 +59,12 @@ Object.defineProperty(exports, "loadRawEdgeCountX", { enumerable: true, get: fun
 Object.defineProperty(exports, "loadEdgeForID2", { enumerable: true, get: function () { return ent_1.loadEdgeForID2; } });
 Object.defineProperty(exports, "loadNodesByEdge", { enumerable: true, get: function () { return ent_1.loadNodesByEdge; } });
 Object.defineProperty(exports, "getEdgeTypeInGroup", { enumerable: true, get: function () { return ent_1.getEdgeTypeInGroup; } });
+// TODO should these even be exported from the root?
+var operations_1 = require("./action/operations");
+Object.defineProperty(exports, "EditNodeOperation", { enumerable: true, get: function () { return operations_1.EditNodeOperation; } });
+Object.defineProperty(exports, "RawQueryOperation", { enumerable: true, get: function () { return operations_1.RawQueryOperation; } });
+Object.defineProperty(exports, "EdgeOperation", { enumerable: true, get: function () { return operations_1.EdgeOperation; } });
+Object.defineProperty(exports, "DeleteNodeOperation", { enumerable: true, get: function () { return operations_1.DeleteNodeOperation; } });
 var global_schema_1 = require("./core/global_schema");
 Object.defineProperty(exports, "setGlobalSchema", { enumerable: true, get: function () { return global_schema_1.setGlobalSchema; } });
 const db_1 = __importDefault(require("./core/db"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha138",
+  "version": "0.1.0-alpha139",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -21,7 +21,7 @@
     "memoizee": "^0.4.15",
     "minimist": "^1.2.7",
     "pascal-case": "^3.1.2",
-    "pg": "^8.8.0",
+    "pg": "^8.11.0",
     "prettier": "^2.8.1",
     "snake-case": "^3.0.4",
     "ts-node": "^10.9.1",

package/parse_schema/parse.js

@@ -268,6 +268,7 @@ async function parseSchema(potentialSchemas, globalSchema) {
             assocEdges: [],
             assocEdgeGroups: [],
             customGraphQLInterfaces: schema.customGraphQLInterfaces,
+            supportUpsert: schema.supportUpsert,
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯

package/schema/base_schema.d.ts

@@ -20,6 +20,7 @@ export declare class EntSchema implements Schema {
     indices: Index[] | undefined;
     hideFromGraphQL?: boolean;
     customGraphQLInterfaces?: string[] | undefined;
+    supportUpsert?: boolean | undefined;
     constructor(cfg: SchemaConfig);
 }
 export declare class EntSchemaWithTZ implements Schema {
@@ -38,6 +39,7 @@ export declare class EntSchemaWithTZ implements Schema {
     indices: Index[] | undefined;
     hideFromGraphQL?: boolean;
     customGraphQLInterfaces?: string[] | undefined;
+    supportUpsert?: boolean | undefined;
     constructor(cfg: SchemaConfig);
 }
 export declare abstract class BaseEntSchema {

package/schema/base_schema.js

@@ -90,6 +90,7 @@ class EntSchema {
         this.hideFromGraphQL = cfg.hideFromGraphQL;
         // TODO annoying that have to list these...
         this.customGraphQLInterfaces = cfg.customGraphQLInterfaces;
+        this.supportUpsert = cfg.supportUpsert;
     }
 }
 exports.EntSchema = EntSchema;
@@ -119,6 +120,7 @@ class EntSchemaWithTZ {
         this.hideFromGraphQL = cfg.hideFromGraphQL;
         // TODO annoying that have to list these...
         this.customGraphQLInterfaces = cfg.customGraphQLInterfaces;
+        this.supportUpsert = cfg.supportUpsert;
     }
 }
 exports.EntSchemaWithTZ = EntSchemaWithTZ;