@snowtop/ent 0.1.0-alpha54 → 0.1.0-alpha59

package/core/ent.js

@@ -22,13 +22,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.loadEdges = exports.defaultEdgeQueryOptions = 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.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = void 0;
+exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.defaultEdgeQueryOptions = 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.__hasGlobalSchema = exports.clearGlobalSchema = exports.setGlobalSchema = exports.EditNodeOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = 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/");
 // TODO kill this and createDataLoader
 class cacheMap {
     constructor(options) {
@@ -473,7 +475,7 @@ class EditNodeOperation {
             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, this.existingEnt.id, "RETURNING *");
+                this.row = await editRow(queryer, options, "RETURNING *");
             }
             else {
                 // @ts-ignore
@@ -523,7 +525,7 @@ class EditNodeOperation {
         };
         if (this.existingEnt) {
             if (this.hasData(this.options.fields)) {
-                editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
+                editRowSync(queryer, options, "RETURNING *");
                 this.reloadRow(queryer, this.existingEnt.id, options);
             }
             else {
@@ -548,8 +550,23 @@ class EditNodeOperation {
     }
 }
 exports.EditNodeOperation = EditNodeOperation;
+let globalSchema;
+function setGlobalSchema(val) {
+    globalSchema = val;
+}
+exports.setGlobalSchema = setGlobalSchema;
+function clearGlobalSchema() {
+    globalSchema = undefined;
+}
+exports.clearGlobalSchema = clearGlobalSchema;
+// used by tests. no guarantee will always exist
+function __hasGlobalSchema() {
+    return globalSchema !== undefined;
+}
+exports.__hasGlobalSchema = __hasGlobalSchema;
 class EdgeOperation {
-    constructor(edgeInput, options) {
+    constructor(builder, edgeInput, options) {
+        this.builder = builder;
         this.edgeInput = edgeInput;
         this.options = options;
     }
@@ -585,7 +602,31 @@ class EdgeOperation {
         }
     }
     getDeleteRowParams(edgeData, edge, context) {
+        let transformed = null;
+        let op = schema_1.SQLStatementOperation.Delete;
+        let updateData = null;
+        // TODO respect disableTransformations
+        if (globalSchema?.transformEdgeWrite) {
+            transformed = globalSchema.transformEdgeWrite({
+                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,
@@ -595,11 +636,35 @@ class EdgeOperation {
     }
     async performDeleteWrite(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
-        return deleteRows(q, params.options, params.clause);
+        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,
+            });
+        }
     }
     performDeleteWriteSync(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
-        return deleteRowsSync(q, params.options, params.clause);
+        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 = {
@@ -618,6 +683,30 @@ class EdgeOperation {
             // maybe when actions exist?
             fields["time"] = new Date().toISOString();
         }
+        const onConflictFields = ["data"];
+        if (globalSchema?.extraEdgeFields) {
+            for (const name in globalSchema.extraEdgeFields) {
+                const f = globalSchema.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;
+        if (globalSchema?.transformEdgeWrite) {
+            transformed = globalSchema.transformEdgeWrite({
+                op: schema_1.SQLStatementOperation.Insert,
+                edge,
+            });
+            if (transformed) {
+                throw new Error(`transforming an insert edge not currently supported`);
+            }
+        }
         return [
             {
                 tableName: edgeData.edgeTable,
@@ -625,7 +714,9 @@ class EdgeOperation {
                 fieldsToLog: fields,
                 context,
             },
-            "ON CONFLICT(id1, edge_type, id2) DO UPDATE SET data = EXCLUDED.data",
+            `ON CONFLICT(id1, edge_type, id2) DO UPDATE SET ${onConflictFields
+                .map((f) => `${f} = EXCLUDED.${f}`)
+                .join(", ")}`,
         ];
     }
     async performInsertWrite(q, edgeData, edge, context) {
@@ -662,7 +753,7 @@ class EdgeOperation {
         }
     }
     symmetricEdge() {
-        return new EdgeOperation({
+        return new EdgeOperation(this.builder, {
             id1: this.edgeInput.id2,
             id1Type: this.edgeInput.id2Type,
             id2: this.edgeInput.id1,
@@ -678,7 +769,7 @@ class EdgeOperation {
         });
     }
     inverseEdge(edgeData) {
-        return new EdgeOperation({
+        return new EdgeOperation(this.builder, {
             id1: this.edgeInput.id2,
             id1Type: this.edgeInput.id2Type,
             id2: this.edgeInput.id1,
@@ -746,7 +837,7 @@ class EdgeOperation {
         if (data) {
             edge.data = data;
         }
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Insert,
             id2Placeholder,
             id1Placeholder,
@@ -767,7 +858,7 @@ class EdgeOperation {
         if (data) {
             edge.data = data;
         }
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Insert,
             id1Placeholder,
             id2Placeholder,
@@ -785,7 +876,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -800,7 +891,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -897,43 +988,42 @@ function createRowSync(queryer, options, suffix) {
     return null;
 }
 exports.createRowSync = createRowSync;
-function buildUpdateQuery(options, id, suffix) {
+function buildUpdateQuery(options, suffix) {
     let valsString = [];
     let values = [];
     let logValues = [];
     const dialect = db_1.default.getDialect();
     let idx = 1;
     for (const key in options.fields) {
-        values.push(options.fields[key]);
+        const val = options.fields[key];
+        values.push(val);
         if (options.fieldsToLog) {
             logValues.push(options.fieldsToLog[key]);
         }
+        // TODO would be nice to use clause here. need update version of the queries so that
+        // we don't have to handle dialect specifics here
+        // can't use clause because of IS NULL
+        // valsString.push(clause.Eq(key, val).clause(idx));
         if (dialect === db_1.Dialect.Postgres) {
             valsString.push(`${key} = $${idx}`);
-            idx++;
         }
         else {
             valsString.push(`${key} = ?`);
         }
+        idx++;
     }
     const vals = valsString.join(", ");
     let query = `UPDATE ${options.tableName} SET ${vals} WHERE `;
-    if (dialect === db_1.Dialect.Postgres) {
-        query = query + `${options.key} = $${idx}`;
-    }
-    else {
-        query = query + `${options.key} = ?`;
-    }
+    query = query + options.whereClause.clause(idx);
+    values.push(...options.whereClause.values());
     if (suffix) {
         query = query + " " + suffix;
     }
     return [query, values, logValues];
 }
 exports.buildUpdateQuery = buildUpdateQuery;
-async function editRow(queryer, options, id, suffix) {
-    const [query, values, logValues] = buildUpdateQuery(options, id, suffix);
-    // add id as value to prepared query
-    values.push(id);
+async function editRow(queryer, options, suffix) {
+    const [query, values, logValues] = buildUpdateQuery(options, suffix);
     const res = await mutateRow(queryer, query, values, logValues, options);
     if (res?.rowCount == 1) {
         // for now assume id primary key
@@ -944,10 +1034,8 @@ async function editRow(queryer, options, id, suffix) {
     return null;
 }
 exports.editRow = editRow;
-function editRowSync(queryer, options, id, suffix) {
-    const [query, values, logValues] = buildUpdateQuery(options, id, suffix);
-    // add id as value to prepared query
-    values.push(id);
+function editRowSync(queryer, options, suffix) {
+    const [query, values, logValues] = buildUpdateQuery(options, suffix);
     const res = mutateRowSync(queryer, query, values, logValues, options);
     if (res?.rowCount == 1) {
         // for now assume id primary key
@@ -998,6 +1086,12 @@ class AssocEdge {
         this.edgeType = data.edge_type;
         this.time = data.time;
         this.data = data.data;
+        this.rawData = data;
+    }
+    __getRawData() {
+        // incase there's extra db fields. useful for tests
+        // in production, a subclass of this should be in use so we won't need this...
+        return this.rawData;
     }
     getCursor() {
         return getCursor({
@@ -1104,6 +1198,21 @@ async function loadEdges(options) {
     return loadCustomEdges({ ...options, ctr: AssocEdge });
 }
 exports.loadEdges = loadEdges;
+function getEdgeClauseAndFields(cls, options) {
+    let fields = edgeFields;
+    if (globalSchema?.transformEdgeRead) {
+        const transformClause = globalSchema.transformEdgeRead();
+        if (!options.disableTransformations) {
+            cls = clause.And(cls, transformClause);
+        }
+        fields = edgeFields.concat(transformClause.columns());
+    }
+    return {
+        cls,
+        fields,
+    };
+}
+exports.getEdgeClauseAndFields = getEdgeClauseAndFields;
 async function loadCustomEdges(options) {
     const { id1, edgeType, context } = options;
     const edgeData = await loadEdgeData(edgeType);
@@ -1115,10 +1224,11 @@ async function loadCustomEdges(options) {
     if (options.queryOptions?.clause) {
         cls = clause.And(cls, options.queryOptions.clause);
     }
+    const { cls: actualClause, fields } = getEdgeClauseAndFields(cls, options);
     const rows = await loadRows({
         tableName: edgeData.edgeTable,
-        fields: edgeFields,
-        clause: cls,
+        fields: fields,
+        clause: actualClause,
         orderby: options.queryOptions?.orderby || defaultOptions.orderby,
         limit: options.queryOptions?.limit || defaultOptions.limit,
         context,
@@ -1134,10 +1244,11 @@ async function loadUniqueEdge(options) {
     if (!edgeData) {
         throw new Error(`error loading edge data for ${edgeType}`);
     }
+    const { cls, fields } = getEdgeClauseAndFields(clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)), options);
     const row = await loadRow({
         tableName: edgeData.edgeTable,
-        fields: edgeFields,
-        clause: clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)),
+        fields: fields,
+        clause: cls,
         context,
     });
     if (!row) {
@@ -1164,11 +1275,12 @@ async function loadRawEdgeCountX(options) {
     if (!edgeData) {
         throw new Error(`error loading edge data for ${edgeType}`);
     }
+    const { cls } = getEdgeClauseAndFields(clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)), options);
     const row = await loadRowX({
         tableName: edgeData.edgeTable,
         // sqlite needs as count otherwise it returns count(1)
         fields: ["count(1) as count"],
-        clause: clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)),
+        clause: cls,
         context,
     });
     return parseInt(row["count"], 10) || 0;

package/core/loaders/assoc_count_loader.js

@@ -41,10 +41,15 @@ class AssocEdgeCountLoader {
         if (!edgeData) {
             throw new Error(`error loading edge data for ${this.edgeType}`);
         }
+        const { cls } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", this.edgeType), {
+            // don't need this..
+            id1: "1",
+            edgeType: this.edgeType,
+        });
         this.loader = (0, raw_count_loader_1.createCountDataLoader)({
             tableName: edgeData.edgeTable,
             groupCol: "id1",
-            clause: clause.Eq("edge_type", this.edgeType),
+            clause: cls,
         });
         return this.loader;
     }

package/core/query/shared_assoc_test.d.ts

@@ -1 +1 @@
-export declare function assocTests(): void;
+export declare function assocTests(global?: boolean): void;

package/core/query/shared_assoc_test.js

@@ -27,7 +27,7 @@ const jest_date_mock_1 = require("jest-date-mock");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
 const db_1 = __importStar(require("../db"));
-function assocTests() {
+function assocTests(global = false) {
     describe("custom edge", () => {
         let user1, user2;
         beforeEach(async () => {
@@ -76,9 +76,16 @@ function assocTests() {
         for (let i = 0; i < numQueries; i++) {
             const query = queries[i];
             let expLimit = disablePaginationBump ? limit : limit + 1;
-            expect(query.qs?.whereClause, `${i}`).toBe(
-            // default limit
-            `id1 = $1 AND edge_type = $2 ORDER BY time DESC LIMIT ${expLimit}`);
+            if (global) {
+                expect(query.qs?.whereClause, `${i}`).toBe(
+                // default limit
+                `id1 = $1 AND edge_type = $2 AND deleted_at IS NULL ORDER BY time DESC LIMIT ${expLimit}`);
+            }
+            else {
+                expect(query.qs?.whereClause, `${i}`).toBe(
+                // default limit
+                `id1 = $1 AND edge_type = $2 ORDER BY time DESC LIMIT ${expLimit}`);
+            }
         }
     }
     function verifyCountQuery({ length = 1, numQueries = 1 }) {
@@ -89,7 +96,12 @@ function assocTests() {
         expect(queries.length).toBe(length);
         for (let i = 0; i < numQueries; i++) {
             const query = queries[i];
-            expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2`);
+            if (global) {
+                expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2 AND deleted_at IS NULL`);
+            }
+            else {
+                expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2`);
+            }
         }
     }
     // TODO need to test multi-ids with id1s that aren't visible...

package/core/query/shared_test.d.ts

@@ -4,11 +4,14 @@ import { EdgeQuery } from "./query";
 interface options<TData extends Data> {
     newQuery: (v: Viewer, user: FakeUser) => EdgeQuery<FakeUser, FakeContact, TData>;
     tableName: string;
+    uniqKey: string;
     entsLength?: number;
     where: string;
     sortCol: string;
     livePostgresDB?: boolean;
     sqlite?: boolean;
+    globalSchema?: boolean;
+    rawDataVerify?(user: FakeUser): Promise<void>;
 }
 export declare const commonTests: <TData extends Data>(opts: options<TData>) => void;
 export {};

package/core/query/shared_test.js

@@ -6,9 +6,12 @@ const ent_1 = require("../ent");
 const viewer_1 = require("../viewer");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
-const test_db_1 = require("../../testutils/db/test_db");
+const temp_db_1 = require("../../testutils/db/temp_db");
 const test_context_1 = require("../../testutils/context/test_context");
 const logger_1 = require("../logger");
+const test_edge_global_schema_1 = require("../../testutils/test_edge_global_schema");
+const builder_1 = require("../../testutils/builder");
+const action_1 = require("../../action");
 class TestQueryFilter {
     constructor(filter, newQuery, ents, defaultViewer) {
         this.filter = filter;
@@ -37,19 +40,19 @@ class TestQueryFilter {
         expect(ids).toEqual(this.filteredContacts.map((contact) => contact.id));
     }
     // rawCount isn't affected by filters...
-    async testRawCount() {
+    async testRawCount(expectedCount) {
         const count = await this.getQuery().queryRawCount();
-        this.verifyRawCount(count);
+        this.verifyRawCount(count, expectedCount);
     }
-    verifyRawCount(count) {
-        expect(count).toBe(test_helpers_1.inputs.length);
+    verifyRawCount(count, expectedCount) {
+        expect(count).toBe(expectedCount ?? test_helpers_1.inputs.length);
     }
-    async testCount() {
+    async testCount(expectedCount) {
         const count = await this.getQuery().queryCount();
-        this.verifyCount(count);
+        this.verifyCount(count, expectedCount);
     }
-    verifyCount(count) {
-        expect(count).toBe(this.filteredContacts.length);
+    verifyCount(count, expectedCount) {
+        expect(count).toBe(expectedCount ?? this.filteredContacts.length);
     }
     async testEdges() {
         const edges = await this.getQuery().queryEdges();
@@ -72,7 +75,7 @@ class TestQueryFilter {
     verifyEnts(ents) {
         (0, test_helpers_1.verifyUserToContacts)(this.user, ents, this.filteredContacts);
     }
-    async testAll() {
+    async testAll(expectedCount) {
         const query = this.getQuery(new viewer_1.IDViewer(this.user.id));
         const [edges, count, ids, rawCount, ents] = await Promise.all([
             query.queryEdges(),
@@ -81,10 +84,10 @@ class TestQueryFilter {
             query.queryRawCount(),
             query.queryEnts(),
         ]);
-        this.verifyCount(count);
+        this.verifyCount(count, expectedCount);
         this.verifyEdges(edges);
         this.verifyIDs(ids);
-        this.verifyRawCount(rawCount);
+        this.verifyRawCount(rawCount, expectedCount);
         this.verifyEnts(ents);
     }
 }
@@ -125,7 +128,19 @@ const commonTests = (opts) => {
         expect(queries.length).toBe(length);
         const query = queries[0];
         const result = [...opts.where.matchAll(preparedVar)];
-        expect(query.qs?.whereClause).toBe(`${opts.where} AND ${opts.sortCol} < $${result.length + 1} ORDER BY ${opts.sortCol} DESC LIMIT 4`);
+        let parts = opts.where.split(" AND ");
+        if (parts[parts.length - 1] === "deleted_at IS NULL") {
+            parts = parts
+                .slice(0, parts.length - 1)
+                .concat([
+                `${opts.sortCol} < $${result.length + 1}`,
+                "deleted_at IS NULL",
+            ]);
+        }
+        else {
+            parts.push(`${opts.sortCol} < $${result.length + 1}`);
+        }
+        expect(query.qs?.whereClause).toBe(`${parts.join(" AND ")} ORDER BY ${opts.sortCol} DESC LIMIT 4`);
     }
     function verifyLastBeforeCursorQuery(length = 1) {
         if (opts.livePostgresDB || opts.sqlite) {
@@ -135,9 +150,21 @@ const commonTests = (opts) => {
         expect(queries.length).toBe(length);
         const query = queries[0];
         const result = [...opts.where.matchAll(preparedVar)];
+        let parts = opts.where.split(" AND ");
+        if (parts[parts.length - 1] === "deleted_at IS NULL") {
+            parts = parts
+                .slice(0, parts.length - 1)
+                .concat([
+                `${opts.sortCol} > $${result.length + 1}`,
+                "deleted_at IS NULL",
+            ]);
+        }
+        else {
+            parts.push(`${opts.sortCol} > $${result.length + 1}`);
+        }
         expect(query.qs?.whereClause).toBe(
         // extra fetched for pagination
-        `${opts.where} AND ${opts.sortCol} > $${result.length + 1} ORDER BY ${opts.sortCol} ASC LIMIT 4`);
+        `${parts.join(" AND ")} ORDER BY ${opts.sortCol} ASC LIMIT 4`);
     }
     function getViewer() {
         // live db, let's do context because we're testing complicated paths
@@ -171,10 +198,12 @@ const commonTests = (opts) => {
             cursorKey: opts.sortCol,
         });
     }
+    if (opts.globalSchema) {
+        (0, ent_1.setGlobalSchema)(test_edge_global_schema_1.testEdgeGlobalSchema);
+    }
     let tdb;
     if (opts.sqlite) {
-        // tableName just to make it unique
-        (0, test_db_1.setupSqlite)(`sqlite:///shared_test+${opts.tableName}.db`, test_helpers_1.tempDBTables);
+        (0, temp_db_1.setupSqlite)(`sqlite:///shared_test+${opts.uniqKey}.db`, () => (0, test_helpers_1.tempDBTables)(opts.globalSchema));
     }
     beforeAll(async () => {
         // want error on by default in tests?
@@ -196,7 +225,7 @@ const commonTests = (opts) => {
     });
     describe("simple queries", () => {
         const filter = new TestQueryFilter((q) => {
-            // no filterzs
+            // no filters
             return q;
         }, opts.newQuery, (contacts) => {
             // nothing to do here
@@ -230,6 +259,55 @@ const commonTests = (opts) => {
             await filter.testAll();
         });
     });
+    describe("after delete", () => {
+        const filter = new TestQueryFilter((q) => {
+            // no filters
+            return q;
+        }, opts.newQuery, (contacts) => {
+            // nothing expected since deleted
+            return [];
+        }, getViewer());
+        beforeEach(async () => {
+            await filter.beforeEach();
+            const action = new builder_1.SimpleAction(filter.user.viewer, index_1.FakeUserSchema, new Map(), action_1.WriteOperation.Edit, filter.user);
+            await Promise.all(filter.allContacts.map(async (contact) => {
+                action.builder.orchestrator.removeOutboundEdge(contact.id, index_1.EdgeType.UserToContacts);
+                const action2 = new builder_1.SimpleAction(filter.user.viewer, index_1.FakeContactSchema, new Map(), action_1.WriteOperation.Delete, contact);
+                await action2.save();
+            }));
+            await action.save();
+            db_mock_1.QueryRecorder.clearQueries();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+            verifyQuery({});
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount(0);
+            verifyCountQuery({});
+        });
+        test("count", async () => {
+            await filter.testCount(0);
+            verifyQuery({});
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+            verifyQuery({});
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+            // no ents so no subsequent query. just the edge query
+            verifyQuery({ length: 1 });
+        });
+        test("all", async () => {
+            await filter.testAll(0);
+        });
+        test("raw_data", async () => {
+            if (opts.rawDataVerify) {
+                await opts.rawDataVerify(filter.user);
+            }
+        });
+    });
     describe("first. no cursor", () => {
         const N = 2;
         const filter = new TestQueryFilter((q) => {

package/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./core/base";
-export { loadEnt, loadCustomData, loadCustomEnts, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, DataOperation, EditNodeOptions, EditNodeOperation, EdgeOperation, DeleteNodeOperation, AssocEdge, AssocEdgeInputOptions, AssocEdgeInput, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, } from "./core/ent";
+export { loadEnt, loadCustomData, loadCustomEnts, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, DataOperation, EditNodeOptions, EditNodeOperation, EdgeOperation, DeleteNodeOperation, AssocEdge, AssocEdgeInputOptions, AssocEdgeInput, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, setGlobalSchema, } from "./core/ent";
 import DB from "./core/db";
 export * from "./core/loaders";
 export { DB };
@@ -20,10 +20,10 @@ declare const query: {
     LessEq: typeof q.LessEq;
     ArrayEq: typeof q.ArrayEq;
     ArrayNotEq: typeof q.ArrayNotEq;
-    ArrayGreater: typeof q.ArrayGreater;
-    ArrayLess: typeof q.ArrayLess;
-    ArrayGreaterEq: typeof q.ArrayGreaterEq;
-    ArrayLessEq: typeof q.ArrayLessEq;
+    PostgresArrayContainsValue: typeof q.PostgresArrayContainsValue;
+    PostgresArrayContains: typeof q.PostgresArrayContains;
+    PostgresArrayNotContainsValue: typeof q.PostgresArrayNotContainsValue;
+    PostgresArrayNotContains: typeof q.PostgresArrayNotContains;
     TsQuery: typeof q.TsQuery;
     PlainToTsQuery: typeof q.PlainToTsQuery;
     PhraseToTsQuery: typeof q.PhraseToTsQuery;