@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/action/operations.js

@@ -0,0 +1,686 @@
+"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 (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalNodeOperation = exports.ConditionalOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.RawQueryOperation = exports.DeleteNodeOperation = void 0;
+const clause = __importStar(require("../core/clause"));
+const action_1 = require("../action");
+const schema_1 = require("../schema/schema");
+const global_schema_1 = require("../core/global_schema");
+const ent_1 = require("../core/ent");
+class DeleteNodeOperation {
+    constructor(id, builder, options) {
+        this.id = id;
+        this.builder = builder;
+        this.options = options;
+    }
+    async performWrite(queryer, context) {
+        let options = {
+            ...this.options,
+            context,
+        };
+        return (0, ent_1.deleteRows)(queryer, options, clause.Eq("id", this.id));
+    }
+    performWriteSync(queryer, context) {
+        let options = {
+            ...this.options,
+            context,
+        };
+        return (0, ent_1.deleteRowsSync)(queryer, options, clause.Eq("id", this.id));
+    }
+}
+exports.DeleteNodeOperation = DeleteNodeOperation;
+class RawQueryOperation {
+    constructor(builder, queries) {
+        this.builder = builder;
+        this.queries = queries;
+    }
+    async performWrite(queryer, context) {
+        for (const q of this.queries) {
+            if (typeof q === "string") {
+                (0, ent_1.logQuery)(q, []);
+                await queryer.query(q);
+            }
+            else {
+                (0, ent_1.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") {
+                (0, ent_1.logQuery)(q, []);
+                queryer.execSync(q);
+            }
+            else {
+                (0, ent_1.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.updatedOp = null;
+        this.resolved = false;
+        this.builder = options.builder;
+        this.placeholderID = options.builder.placeholderID;
+    }
+    resolve(executor) {
+        if (!this.options.fieldsToResolve.length) {
+            return;
+        }
+        if (this.resolved) {
+            throw new Error(`already resolved ${this.placeholderID}`);
+        }
+        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;
+        this.resolved = true;
+    }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
+    buildOnConflictQuery(options) {
+        // assumes onConflict has been checked already...
+        const clauses = [];
+        for (const col of this.options.onConflict.onConflictCols) {
+            clauses.push(clause.Eq(col, options.fields[col]));
+        }
+        const cls = clause.AndOptional(...clauses);
+        const query = this.buildReloadQuery(options, cls);
+        return { cls, query };
+    }
+    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 (0, ent_1.editRow)(queryer, options, "RETURNING *");
+            }
+            else {
+                // @ts-ignore
+                this.row = this.existingEnt["data"];
+            }
+        }
+        else {
+            // TODO: eventually, when we officially support auto-increment ids. need to make sure/test that this works
+            // https://github.com/lolopinto/ent/issues/1431
+            this.row = await (0, ent_1.createRow)(queryer, options, "RETURNING *");
+            const key = this.options.key;
+            if (this.row && this.row[key] !== this.options.fields[key]) {
+                this.updatedOp = {
+                    builder: this.options.builder,
+                    operation: action_1.WriteOperation.Edit,
+                };
+            }
+            if (this.row === null &&
+                this.options.onConflict &&
+                !this.options.onConflict.updateCols?.length) {
+                // no row returned and on conflict, do nothing, have to fetch the conflict row back...
+                const { cls, query } = this.buildOnConflictQuery(options);
+                (0, ent_1.logQuery)(query, cls.logValues());
+                const res = await queryer.query(query, cls.values());
+                this.row = res.rows[0];
+                this.updatedOp = {
+                    builder: this.options.builder,
+                    operation: action_1.WriteOperation.Edit,
+                };
+            }
+        }
+    }
+    buildReloadQuery(options, cls) {
+        // 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();
+        if (opts.clause) {
+            let optionClause;
+            if (typeof opts.clause === "function") {
+                optionClause = opts.clause();
+            }
+            else {
+                optionClause = opts.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(cls, optionClause);
+            }
+        }
+        const query = (0, ent_1.buildQuery)({
+            fields: opts.fields.length ? opts.fields : ["*"],
+            tableName: options.tableName,
+            clause: cls,
+        });
+        return query;
+    }
+    reloadRow(queryer, id, options) {
+        const query = this.buildReloadQuery(options, clause.Eq(options.key, id));
+        // 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
+        (0, ent_1.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)) {
+                (0, ent_1.editRowSync)(queryer, options, "RETURNING *");
+                this.reloadRow(queryer, this.existingEnt.id, options);
+            }
+            else {
+                // @ts-ignore
+                this.row = this.existingEnt["data"];
+            }
+        }
+        else {
+            (0, ent_1.createRowSync)(queryer, options, "RETURNING *");
+            const id = options.fields[options.key];
+            this.reloadRow(queryer, id, options);
+            const key = this.options.key;
+            if (this.row && this.row[key] !== this.options.fields[key]) {
+                this.updatedOp = {
+                    builder: this.options.builder,
+                    operation: action_1.WriteOperation.Edit,
+                };
+            }
+            // if we can't find the id, try and load the on conflict row
+            // no returning * with sqlite and have to assume the row was created more often than not
+            // there's a world in which we combine into one query if on-conflict
+            // seems like it's safer not to and sqlite (only sync client we currently have) is fast enough
+            // (single-process) that it's fine to do two queries
+            // we wanna do this in both on conflict do nothing or on conflict update
+            if (this.row === null && this.options.onConflict) {
+                const { cls, query } = this.buildOnConflictQuery(options);
+                // 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
+                (0, ent_1.logQuery)(query, cls.logValues());
+                const r = queryer.querySync(query, cls.values());
+                if (r.rows.length === 1) {
+                    this.row = r.rows[0];
+                }
+                this.updatedOp = {
+                    builder: this.options.builder,
+                    operation: action_1.WriteOperation.Edit,
+                };
+            }
+        }
+    }
+    returnedRow() {
+        return this.row;
+    }
+    createdEnt(viewer) {
+        if (!this.row) {
+            return null;
+        }
+        return new this.options.loadEntOptions.ent(viewer, this.row);
+    }
+    updatedOperation() {
+        return this.updatedOp;
+    }
+}
+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 (0, ent_1.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;
+        const transformedEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
+        if (transformedEdgeWrite && !edge.disableTransformations) {
+            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 (0, ent_1.deleteRows)(q, params.options, params.clause);
+        }
+        else {
+            if (params.op !== schema_1.SQLStatementOperation.Update) {
+                throw new Error(`invalid operation ${params.op}`);
+            }
+            await (0, ent_1.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 (0, ent_1.deleteRowsSync)(q, params.options, params.clause);
+        }
+        else {
+            if (params.op !== schema_1.SQLStatementOperation.Update) {
+                throw new Error(`invalid operation ${params.op}`);
+            }
+            (0, ent_1.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);
+                }
+            }
+        }
+        let transformed = null;
+        const transformEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
+        if (transformEdgeWrite && !edge.disableTransformations) {
+            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 (0, ent_1.createRow)(q, options, suffix);
+    }
+    performInsertWriteSync(q, edgeData, edge, context) {
+        const [options, suffix] = this.getInsertRowParams(edgeData, edge, context);
+        (0, ent_1.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,
+            disableTransformations: this.edgeInput.disableTransformations,
+        }, {
+            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,
+            disableTransformations: this.edgeInput.disableTransformations,
+        }, {
+            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, options) {
+        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: "",
+            disableTransformations: options?.disableTransformations,
+        };
+        return new EdgeOperation(builder, edge, {
+            operation: action_1.WriteOperation.Delete,
+        });
+    }
+    static removeOutboundEdge(builder, edgeType, id2, options) {
+        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: "",
+            disableTransformations: options?.disableTransformations,
+        };
+        return new EdgeOperation(builder, edge, {
+            operation: action_1.WriteOperation.Delete,
+        });
+    }
+}
+exports.EdgeOperation = EdgeOperation;
+class ConditionalOperation {
+    constructor(op, conditionalBuilder) {
+        this.op = op;
+        this.conditionalBuilder = conditionalBuilder;
+        this.shortCircuited = false;
+        this.builder = op.builder;
+        this.placeholderID = op.placeholderID;
+    }
+    shortCircuit(executor) {
+        this.shortCircuited = executor.builderOpChanged(this.conditionalBuilder);
+        return this.shortCircuited;
+    }
+    async preFetch(queryer, context) {
+        if (this.op.preFetch) {
+            return this.op.preFetch(queryer, context);
+        }
+    }
+    performWriteSync(queryer, context) {
+        this.op.performWriteSync(queryer, context);
+    }
+    performWrite(queryer, context) {
+        return this.op.performWrite(queryer, context);
+    }
+    returnedRow() {
+        if (this.op.returnedRow) {
+            return this.op.returnedRow();
+        }
+        return null;
+    }
+    updatedOperation() {
+        if (this.op.updatedOperation) {
+            return this.op.updatedOperation();
+        }
+        return null;
+    }
+    resolve(executor) {
+        if (this.op.resolve) {
+            return this.op.resolve(executor);
+        }
+    }
+    async postFetch(queryer, context) {
+        if (this.op.postFetch) {
+            return this.op.postFetch(queryer, context);
+        }
+    }
+}
+exports.ConditionalOperation = ConditionalOperation;
+// separate because we need to implement createdEnt and we manually run those before edge/other operations in executors
+class ConditionalNodeOperation extends ConditionalOperation {
+    createdEnt(viewer) {
+        if (this.op.createdEnt) {
+            return this.op.createdEnt(viewer);
+        }
+        return null;
+    }
+    updatedOperation() {
+        if (!this.op.updatedOperation) {
+            return null;
+        }
+        const ret = this.op.updatedOperation();
+        if (ret !== null) {
+            return ret;
+        }
+        if (!this.shortCircuited) {
+            return null;
+        }
+        // hack. if this short circuited, claim that this updated as an edit and it should invalidate other builders
+        // this API needs to change or EditNodeOperation needs to be used instead of this...
+        return {
+            operation: action_1.WriteOperation.Edit,
+            builder: this.builder,
+        };
+    }
+}
+exports.ConditionalNodeOperation = ConditionalNodeOperation;