@aglyn/tenant-data-admin 1.0.0-beta.196 → 1.0.0-beta.198

package/src/lib/server/test-firestore-queries.js

@@ -0,0 +1,640 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * A Firestore stand-in that QUERIES (AGL-3320). Test-only; deliberately not
+ * exported from the barrel, like `test-firestore.ts` beside it.
+ *
+ * That fake holds documents and nothing else, which is enough for code that
+ * reads a document by id. A consent group change pages whole subcollections
+ * by document id, filters on nested map fields, counts, writes through a
+ * `BulkWriter` with `lastUpdateTime` preconditions and takes transactions —
+ * and its correctness properties (a second pass writes nothing, a resumed
+ * pass skips nothing) are properties of exactly those mechanics, so a fake
+ * that skipped them would be asserting itself.
+ *
+ * What is modeled, and is load-bearing:
+ *
+ *  - A document missing a field never matches a filter or an ordering on it,
+ *    including `!=` — the rule that makes an `orderBy` on a data field drop
+ *    documents, and the reason every scan here pages by `__name__`.
+ *  - `update()` needs the document to exist, replaces the value at each
+ *    (dotted) path whole, and fails its `lastUpdateTime` precondition when
+ *    the document was written since; `create()` fails on an existing one.
+ *    The error codes are gRPC's: 5, 6, 9.
+ *  - `FieldValue` sentinels are applied, not stored: `delete`,
+ *    `serverTimestamp` (the fake clock), `increment`, `arrayUnion`,
+ *    `arrayRemove`.
+ *  - Every write moves `updateTime`, and a `BulkWriter` runs its queued
+ *    writes when it is flushed or closed, rejecting each failed write's
+ *    promise the way the real one does.
+ *  - A transaction is SERIALIZABLE: one whose reads changed before it
+ *    committed runs its body again, as the SDK retries a contended one, so
+ *    two transactions racing on one document cannot both act on what they
+ *    read. That is the property a start's "no change in flight" rests on.
+ *
+ * What is not: a `BulkWriter`'s own retries, which nothing here branches on.
+ */ import { FieldValue, Timestamp } from "firebase-admin/firestore";
+/** A Firestore-style error: the gRPC code the SDK attaches. */ function grpcError(code, message) {
+    return Object.assign(new Error(message), {
+        code
+    });
+}
+const isTransform = (value)=>value instanceof FieldValue;
+function clone(value) {
+    if (value === null || typeof value !== 'object') return value;
+    if (value instanceof Timestamp || value instanceof FieldValue) return value;
+    if (Array.isArray(value)) return value.map((item)=>clone(item));
+    const out = {};
+    for (const [key, item] of Object.entries(value))out[key] = clone(item);
+    return out;
+}
+/** A field as a plain dotted path; a `FieldPath`'s segments are joined unquoted. */ function fieldName(field) {
+    if (typeof field === 'string') return field;
+    const segments = field.segments;
+    return Array.isArray(segments) ? segments.join('.') : String(field);
+}
+/** The value at a dotted path, or `undefined` when any segment is missing. */ function valueAt(data, path) {
+    let node = data;
+    for (const segment of path.split('.')){
+        if (!node || typeof node !== 'object' || Array.isArray(node)) return undefined;
+        node = node[segment];
+    }
+    return node;
+}
+/** Firestore's cross-type order: null, booleans, numbers, timestamps, strings, the rest. */ function rank(value) {
+    if (value === null) return 0;
+    if (typeof value === 'boolean') return 1;
+    if (typeof value === 'number') return 2;
+    if (value instanceof Timestamp) return 3;
+    if (typeof value === 'string') return 4;
+    if (Array.isArray(value)) return 6;
+    return 7;
+}
+function compare(a, b) {
+    const byRank = rank(a) - rank(b);
+    if (byRank !== 0) return byRank;
+    if (a instanceof Timestamp && b instanceof Timestamp) {
+        return a.seconds - b.seconds || a.nanoseconds - b.nanoseconds;
+    }
+    if (typeof a === 'number' && typeof b === 'number') return a - b;
+    if (typeof a === 'string' && typeof b === 'string') return a < b ? -1 : a > b ? 1 : 0;
+    if (typeof a === 'boolean' && typeof b === 'boolean') return Number(a) - Number(b);
+    const left = JSON.stringify(a);
+    const right = JSON.stringify(b);
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+const equal = (a, b)=>rank(a) === rank(b) && compare(a, b) === 0;
+function matches(id, data, filter) {
+    const actual = filter.field === '__name__' ? id : valueAt(data, filter.field);
+    if (actual === undefined) return false;
+    const { op, value } = filter;
+    switch(op){
+        case '==':
+            return equal(actual, value);
+        case '!=':
+            return actual !== null && !equal(actual, value);
+        case '<':
+            return rank(actual) === rank(value) && compare(actual, value) < 0;
+        case '<=':
+            return rank(actual) === rank(value) && compare(actual, value) <= 0;
+        case '>':
+            return rank(actual) === rank(value) && compare(actual, value) > 0;
+        case '>=':
+            return rank(actual) === rank(value) && compare(actual, value) >= 0;
+        case 'in':
+            return value.some((candidate)=>equal(actual, candidate));
+        case 'not-in':
+            return actual !== null && !value.some((candidate)=>equal(actual, candidate));
+        case 'array-contains':
+            return Array.isArray(actual) && actual.some((item)=>equal(item, value));
+        case 'array-contains-any':
+            return Array.isArray(actual) && actual.some((item)=>value.some((candidate)=>equal(item, candidate)));
+        default:
+            throw new Error(`test-firestore-queries: unsupported operator ${op}`);
+    }
+}
+export function queryFakeFirestore(seed = {}, options = {}) {
+    var _options_nowMs;
+    const store = new Map();
+    let nowMs = (_options_nowMs = options.nowMs) != null ? _options_nowMs : Date.UTC(2026, 8, 24);
+    /** Keeps every write's `updateTime` distinct even on a frozen clock. */ let tick = 0;
+    let writeCount = 0;
+    const failing = new Map();
+    let autoIds = 0;
+    const stamp = ()=>Timestamp.fromMillis(nowMs + (tick += 0.001));
+    const nextAutoId = ()=>{
+        autoIds += 1;
+        return String(autoIds).padStart(8, '0');
+    };
+    for (const [path, data] of Object.entries(seed)){
+        const at = Timestamp.fromMillis(nowMs);
+        store.set(path, {
+            data: clone(data),
+            createTime: at,
+            updateTime: at
+        });
+    }
+    /** Applies a write's value at one path of `target`, honoring transforms. */ function put(target, path, value, previous) {
+        const [head, ...rest] = path;
+        if (rest.length) {
+            const child = target[head];
+            const next = child && typeof child === 'object' && !Array.isArray(child) ? child : {};
+            target[head] = next;
+            put(next, rest, value, valueAt(previous, rest.join('.')));
+            return;
+        }
+        if (isTransform(value)) {
+            const current = target[head];
+            switch(value.methodName){
+                case 'FieldValue.delete':
+                    delete target[head];
+                    return;
+                case 'FieldValue.serverTimestamp':
+                    target[head] = Timestamp.fromMillis(nowMs);
+                    return;
+                case 'FieldValue.increment':
+                    {
+                        const operand = value.operand;
+                        target[head] = (typeof current === 'number' ? current : 0) + operand;
+                        return;
+                    }
+                case 'FieldValue.arrayUnion':
+                    {
+                        const elements = value.elements;
+                        const base = Array.isArray(current) ? [
+                            ...current
+                        ] : [];
+                        for (const element of elements){
+                            if (!base.some((item)=>equal(item, element))) base.push(element);
+                        }
+                        target[head] = base;
+                        return;
+                    }
+                case 'FieldValue.arrayRemove':
+                    {
+                        const elements = value.elements;
+                        target[head] = (Array.isArray(current) ? current : []).filter((item)=>!elements.some((element)=>equal(item, element)));
+                        return;
+                    }
+                default:
+                    throw new Error(`test-firestore-queries: unsupported transform ${value.methodName}`);
+            }
+        }
+        target[head] = materialize(value);
+    }
+    /** A written value with any nested transforms resolved against nothing. */ function materialize(value) {
+        if (value === undefined) throw new Error('test-firestore-queries: undefined is not a Firestore value');
+        if (value === null || typeof value !== 'object') return value;
+        if (value instanceof Timestamp) return value;
+        if (isTransform(value)) {
+            if (value.methodName === 'FieldValue.serverTimestamp') return Timestamp.fromMillis(nowMs);
+            throw new Error(`test-firestore-queries: ${value.methodName} inside a nested value`);
+        }
+        if (Array.isArray(value)) return value.map((item)=>materialize(item));
+        const out = {};
+        for (const [key, item] of Object.entries(value)){
+            if (isTransform(item) && item.methodName === 'FieldValue.delete') continue;
+            out[key] = materialize(item);
+        }
+        return out;
+    }
+    function mergeInto(target, source) {
+        for (const [key, value] of Object.entries(source)){
+            if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Timestamp) && !isTransform(value)) {
+                const child = target[key];
+                const next = child && typeof child === 'object' && !Array.isArray(child) && !(child instanceof Timestamp) ? child : {};
+                target[key] = next;
+                mergeInto(next, value);
+            } else {
+                put(target, [
+                    key
+                ], value, target[key]);
+            }
+        }
+    }
+    /** Why a write cannot apply, or `null`. */ function refusal(write) {
+        var _write_precondition;
+        const failure = failing.get(write.path);
+        if (failure) return failure;
+        const existing = store.get(write.path);
+        if (write.type === 'create' && existing) {
+            return grpcError(6, `ALREADY_EXISTS: ${write.path}`);
+        }
+        if (write.type === 'update' && !existing) {
+            return grpcError(5, `NOT_FOUND: ${write.path}`);
+        }
+        if ((write.type === 'update' || write.type === 'delete') && ((_write_precondition = write.precondition) == null ? void 0 : _write_precondition.lastUpdateTime)) {
+            if (!existing || !existing.updateTime.isEqual(write.precondition.lastUpdateTime)) {
+                return grpcError(9, `FAILED_PRECONDITION: ${write.path}`);
+            }
+        }
+        return null;
+    }
+    function apply(write) {
+        var _ref;
+        const existing = store.get(write.path);
+        const at = stamp();
+        writeCount += 1;
+        if (write.type === 'delete') {
+            store.delete(write.path);
+            return at;
+        }
+        if (write.type === 'update') {
+            var _ref1, _ref2;
+            const data = clone((_ref1 = existing == null ? void 0 : existing.data) != null ? _ref1 : {});
+            for (const [path, value] of Object.entries(write.data)){
+                put(data, path.split('.'), value, valueAt(existing == null ? void 0 : existing.data, path));
+            }
+            store.set(write.path, {
+                data,
+                createTime: (_ref2 = existing == null ? void 0 : existing.createTime) != null ? _ref2 : at,
+                updateTime: at
+            });
+            return at;
+        }
+        if (write.type === 'set' && write.merge) {
+            var _ref3, _ref4;
+            const data = clone((_ref3 = existing == null ? void 0 : existing.data) != null ? _ref3 : {});
+            mergeInto(data, write.data);
+            store.set(write.path, {
+                data,
+                createTime: (_ref4 = existing == null ? void 0 : existing.createTime) != null ? _ref4 : at,
+                updateTime: at
+            });
+            return at;
+        }
+        const data = {};
+        mergeInto(data, write.data);
+        store.set(write.path, {
+            data,
+            createTime: (_ref = existing == null ? void 0 : existing.createTime) != null ? _ref : at,
+            updateTime: at
+        });
+        return at;
+    }
+    function snapshot(path) {
+        const stored = store.get(path);
+        const id = path.split('/').pop();
+        return {
+            id,
+            ref: docRef(path),
+            exists: stored !== undefined,
+            data: ()=>stored ? clone(stored.data) : undefined,
+            get: (field)=>clone(valueAt(stored == null ? void 0 : stored.data, fieldName(field))),
+            updateTime: stored == null ? void 0 : stored.updateTime,
+            createTime: stored == null ? void 0 : stored.createTime
+        };
+    }
+    function docRef(path) {
+        const segments = path.split('/');
+        if (segments.length % 2 !== 0) throw new Error(`test-firestore-queries: ${path} is not a document path`);
+        const ref = {
+            id: segments[segments.length - 1],
+            path,
+            collection: (name)=>collectionRef(`${path}/${name}`),
+            get: async ()=>snapshot(path),
+            set: async (data, setOptions)=>run({
+                    type: 'set',
+                    path,
+                    data,
+                    merge: (setOptions == null ? void 0 : setOptions.merge) === true
+                }),
+            update: async (data, precondition)=>run({
+                    type: 'update',
+                    path,
+                    data,
+                    precondition
+                }),
+            create: async (data)=>run({
+                    type: 'create',
+                    path,
+                    data
+                }),
+            delete: async (precondition)=>run({
+                    type: 'delete',
+                    path,
+                    precondition
+                }),
+            isEqual: (other)=>(other == null ? void 0 : other.path) === path
+        };
+        Object.defineProperty(ref, 'parent', {
+            get: ()=>collectionRef(segments.slice(0, -1).join('/'))
+        });
+        return ref;
+    }
+    function run(write) {
+        const failure = refusal(write);
+        if (failure) throw failure;
+        return {
+            writeTime: apply(write)
+        };
+    }
+    function execute(state) {
+        const prefix = `${state.path}/`;
+        let rows = [
+            ...store.entries()
+        ].filter(([path])=>path.startsWith(prefix) && !path.slice(prefix.length).includes('/')).map(([path, stored])=>({
+                path,
+                id: path.slice(prefix.length),
+                data: stored.data
+            })).filter((row)=>state.filters.every((filter)=>matches(row.id, row.data, filter)));
+        const orders = [
+            ...state.orders
+        ];
+        if (!orders.some((order)=>order.field === '__name__')) {
+            orders.push({
+                field: '__name__',
+                direction: 'asc'
+            });
+        }
+        rows = rows.filter((row)=>orders.every((order)=>order.field === '__name__' || valueAt(row.data, order.field) !== undefined));
+        const keyOf = (row, field)=>field === '__name__' ? row.id : valueAt(row.data, field);
+        rows.sort((a, b)=>{
+            for (const order of orders){
+                const result = compare(keyOf(a, order.field), keyOf(b, order.field));
+                if (result !== 0) return order.direction === 'desc' ? -result : result;
+            }
+            return 0;
+        });
+        if (state.after) {
+            const cursor = state.after;
+            rows = rows.filter((row)=>{
+                for(let index = 0; index < cursor.length; index += 1){
+                    const order = orders[index];
+                    const result = compare(keyOf(row, order.field), cursor[index]);
+                    const signed = order.direction === 'desc' ? -result : result;
+                    if (signed !== 0) return signed > 0;
+                }
+                return false;
+            });
+        }
+        if (state.limit !== null) rows = rows.slice(0, state.limit);
+        return rows.map((row)=>snapshot(row.path));
+    }
+    function query(state) {
+        return {
+            where: (field, op, value)=>query(_extends({}, state, {
+                    filters: [
+                        ...state.filters,
+                        {
+                            field: fieldName(field),
+                            op,
+                            value
+                        }
+                    ]
+                })),
+            orderBy: (field, direction = 'asc')=>query(_extends({}, state, {
+                    orders: [
+                        ...state.orders,
+                        {
+                            field: fieldName(field),
+                            direction
+                        }
+                    ]
+                })),
+            startAfter: (...values)=>query(_extends({}, state, {
+                    after: values
+                })),
+            limit: (limit)=>query(_extends({}, state, {
+                    limit
+                })),
+            count: ()=>({
+                    get: async ()=>{
+                        const total = execute(_extends({}, state, {
+                            limit: null,
+                            after: state.after
+                        })).length;
+                        const count = state.limit === null ? total : Math.min(total, state.limit);
+                        return {
+                            data: ()=>({
+                                    count
+                                })
+                        };
+                    }
+                }),
+            get: async ()=>{
+                const docs = execute(state);
+                return {
+                    docs,
+                    size: docs.length,
+                    empty: docs.length === 0,
+                    forEach: (fn)=>docs.forEach(fn)
+                };
+            }
+        };
+    }
+    function collectionRef(path) {
+        const base = query({
+            path,
+            filters: [],
+            orders: [],
+            after: null,
+            limit: null
+        });
+        return _extends({}, base, {
+            id: path.split('/').pop(),
+            path,
+            doc: (id)=>docRef(`${path}/${id != null ? id : nextAutoId()}`),
+            add: async (data)=>{
+                const ref = docRef(`${path}/${nextAutoId()}`);
+                run({
+                    type: 'create',
+                    path: ref.path,
+                    data
+                });
+                return ref;
+            }
+        });
+    }
+    function transactionOrBatch() {
+        const writes = [];
+        const reads = new Map();
+        const read = (path)=>{
+            var _ref;
+            var _store_get;
+            if (!reads.has(path)) reads.set(path, (_ref = (_store_get = store.get(path)) == null ? void 0 : _store_get.updateTime) != null ? _ref : null);
+            return snapshot(path);
+        };
+        const api = {
+            get: async (target)=>typeof (target == null ? void 0 : target.path) === 'string' && target.path.split('/').length % 2 === 0 ? read(target.path) : target.get(),
+            getAll: async (...refs)=>refs.map((ref)=>read(ref.path)),
+            set: (ref, data, setOptions)=>{
+                writes.push({
+                    type: 'set',
+                    path: ref.path,
+                    data,
+                    merge: (setOptions == null ? void 0 : setOptions.merge) === true
+                });
+                return api;
+            },
+            update: (ref, data, precondition)=>{
+                writes.push({
+                    type: 'update',
+                    path: ref.path,
+                    data,
+                    precondition
+                });
+                return api;
+            },
+            create: (ref, data)=>{
+                writes.push({
+                    type: 'create',
+                    path: ref.path,
+                    data
+                });
+                return api;
+            },
+            delete: (ref, precondition)=>{
+                writes.push({
+                    type: 'delete',
+                    path: ref.path,
+                    precondition
+                });
+                return api;
+            }
+        };
+        return {
+            writes,
+            reads,
+            api
+        };
+    }
+    /** Whether every document a transaction read is still as it read it. */ function unchanged(reads) {
+        for (const [path, seen] of reads){
+            var _ref;
+            var _store_get;
+            const now = (_ref = (_store_get = store.get(path)) == null ? void 0 : _store_get.updateTime) != null ? _ref : null;
+            if (seen === null ? now !== null : now === null || !now.isEqual(seen)) return false;
+        }
+        return true;
+    }
+    /** All or nothing, in order: every write is checked against the state the earlier ones leave. */ function commitAll(writes) {
+        const saved = new Map(store);
+        const count = writeCount;
+        try {
+            for (const write of writes)run(write);
+        } catch (error) {
+            store.clear();
+            for (const [path, stored] of saved)store.set(path, stored);
+            writeCount = count;
+            throw error;
+        }
+    }
+    const firestore = {
+        collection: (path)=>collectionRef(path),
+        doc: (path)=>docRef(path),
+        getAll: async (...refs)=>refs.map((ref)=>snapshot(ref.path)),
+        runTransaction: async (body)=>{
+            for(let attempt = 0; attempt < 5; attempt += 1){
+                const { writes, reads, api } = transactionOrBatch();
+                const result = await body(api);
+                if (!unchanged(reads)) continue;
+                commitAll(writes);
+                return result;
+            }
+            throw grpcError(10, 'ABORTED: too much contention');
+        },
+        batch: ()=>{
+            const { writes, api } = transactionOrBatch();
+            return _extends({}, api, {
+                commit: async ()=>commitAll(writes)
+            });
+        },
+        bulkWriter: ()=>{
+            const queued = [];
+            const enqueue = (write)=>new Promise((resolve, reject)=>queued.push({
+                        write,
+                        resolve,
+                        reject
+                    }));
+            const drain = async ()=>{
+                while(queued.length){
+                    const next = queued.shift();
+                    try {
+                        next.resolve(run(next.write));
+                    } catch (error) {
+                        next.reject(error);
+                    }
+                }
+            };
+            return {
+                create: (ref, data)=>enqueue({
+                        type: 'create',
+                        path: ref.path,
+                        data
+                    }),
+                set: (ref, data, setOptions)=>enqueue({
+                        type: 'set',
+                        path: ref.path,
+                        data,
+                        merge: (setOptions == null ? void 0 : setOptions.merge) === true
+                    }),
+                update: (ref, data, precondition)=>enqueue({
+                        type: 'update',
+                        path: ref.path,
+                        data,
+                        precondition
+                    }),
+                delete: (ref, precondition)=>enqueue({
+                        type: 'delete',
+                        path: ref.path,
+                        precondition
+                    }),
+                onWriteError: ()=>undefined,
+                flush: drain,
+                close: drain
+            };
+        },
+        seed: (path, data)=>{
+            var _ref;
+            const at = Timestamp.fromMillis(nowMs);
+            const existing = store.get(path);
+            store.set(path, {
+                data: clone(data),
+                createTime: (_ref = existing == null ? void 0 : existing.createTime) != null ? _ref : at,
+                updateTime: stamp()
+            });
+        },
+        read: (path)=>{
+            const stored = store.get(path);
+            return stored ? clone(stored.data) : undefined;
+        },
+        docs: (collectionPath)=>{
+            const prefix = `${collectionPath}/`;
+            const out = {};
+            for (const [path, stored] of store){
+                const rest = path.slice(prefix.length);
+                if (path.startsWith(prefix) && !rest.includes('/')) out[rest] = clone(stored.data);
+            }
+            return out;
+        },
+        writes: ()=>writeCount,
+        resetWrites: ()=>{
+            writeCount = 0;
+        },
+        setNow: (ms)=>{
+            nowMs = ms;
+        },
+        failWritesTo: (path, error)=>{
+            if (error) failing.set(path, error);
+            else failing.delete(path);
+        }
+    };
+    return firestore;
+}
+
+//# sourceMappingURL=test-firestore-queries.js.map