@aglyn/plugins-commerce 1.0.0-beta.230 → 1.0.0-beta.232

package/src/lib/testing/fake-firestore.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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.
+ */
+/**
+ * An in-memory stand-in for the Admin SDK's Firestore, for the register's
+ * money-path specs (AGL-3607). Faithful where the code under test leans on
+ * it: `create()` refuses an existing document, `update()` refuses a missing
+ * one, merge-sets merge one level, and the `increment`, `delete` and
+ * `arrayUnion` sentinels resolve against the stored value. A transaction
+ * buffers its writes and applies them at commit, so a throw inside it writes
+ * nothing.
+ */
+declare const INCREMENT: unique symbol;
+declare const DELETE: unique symbol;
+declare const UNION: unique symbol;
+export declare const fakeFieldValue: {
+    increment: (value: number) => {
+        [INCREMENT]: number;
+    };
+    delete: () => {
+        [DELETE]: boolean;
+    };
+    arrayUnion: (...values: unknown[]) => {
+        [UNION]: unknown[];
+    };
+    serverTimestamp: () => string;
+};
+export declare const fakeDocs: Map<string, Record<string, any>>;
+export declare function docRef(path: string): any;
+export declare const fakeFirestore: any;
+export declare function resetFakeFirestore(): void;
+export {};

package/src/lib/testing/fake-firestore.js

@@ -0,0 +1,189 @@
+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.
+ */ /**
+ * An in-memory stand-in for the Admin SDK's Firestore, for the register's
+ * money-path specs (AGL-3607). Faithful where the code under test leans on
+ * it: `create()` refuses an existing document, `update()` refuses a missing
+ * one, merge-sets merge one level, and the `increment`, `delete` and
+ * `arrayUnion` sentinels resolve against the stored value. A transaction
+ * buffers its writes and applies them at commit, so a throw inside it writes
+ * nothing.
+ */ const INCREMENT = Symbol('increment');
+const DELETE = Symbol('delete');
+const UNION = Symbol('arrayUnion');
+export const fakeFieldValue = {
+    increment: (value)=>({
+            [INCREMENT]: value
+        }),
+    delete: ()=>({
+            [DELETE]: true
+        }),
+    arrayUnion: (...values)=>({
+            [UNION]: values
+        }),
+    serverTimestamp: ()=>'<server-timestamp>'
+};
+export const fakeDocs = new Map();
+let autoId = 0;
+function resolveValue(existing, value) {
+    if (value && typeof value === 'object') {
+        if (INCREMENT in value) return (Number(existing) || 0) + value[INCREMENT];
+        if (UNION in value) {
+            const base = Array.isArray(existing) ? [
+                ...existing
+            ] : [];
+            for (const item of value[UNION]){
+                if (!base.some((entry)=>JSON.stringify(entry) === JSON.stringify(item))) base.push(item);
+            }
+            return base;
+        }
+    }
+    return value;
+}
+function applyWrite(path, value, mode) {
+    const existing = fakeDocs.get(path);
+    if (mode === 'update' && !existing) {
+        const error = new Error(`NOT_FOUND: ${path}`);
+        error.code = 5;
+        throw error;
+    }
+    const next = mode === 'set' ? {} : _extends({}, existing != null ? existing : {});
+    for (const [key, raw] of Object.entries(value)){
+        if (raw && typeof raw === 'object' && DELETE in raw) {
+            delete next[key];
+            continue;
+        }
+        if (mode === 'merge' && raw && typeof raw === 'object' && !Array.isArray(raw) && !(INCREMENT in raw) && !(UNION in raw) && next[key] && typeof next[key] === 'object' && !Array.isArray(next[key])) {
+            const nested = _extends({}, next[key]);
+            for (const [inner, innerValue] of Object.entries(raw)){
+                if (innerValue && typeof innerValue === 'object' && DELETE in innerValue) {
+                    delete nested[inner];
+                } else {
+                    nested[inner] = resolveValue(nested[inner], innerValue);
+                }
+            }
+            next[key] = nested;
+            continue;
+        }
+        next[key] = resolveValue(existing == null ? void 0 : existing[key], raw);
+    }
+    fakeDocs.set(path, next);
+}
+function snapshotOf(path) {
+    const data = fakeDocs.get(path);
+    return {
+        id: path.split('/').pop(),
+        exists: data !== undefined,
+        ref: docRef(path),
+        data: ()=>data ? JSON.parse(JSON.stringify(data)) : undefined,
+        get: (field)=>data == null ? void 0 : data[field]
+    };
+}
+export function docRef(path) {
+    return {
+        id: path.split('/').pop(),
+        path,
+        get: async ()=>snapshotOf(path),
+        set: async (value, options)=>applyWrite(path, value, (options == null ? void 0 : options.merge) ? 'merge' : 'set'),
+        update: async (value)=>applyWrite(path, value, 'update'),
+        create: async (value)=>{
+            if (fakeDocs.has(path)) {
+                const error = new Error(`ALREADY_EXISTS: ${path}`);
+                error.code = 6;
+                throw error;
+            }
+            applyWrite(path, value, 'set');
+        },
+        delete: async ()=>{
+            fakeDocs.delete(path);
+        },
+        collection: (name)=>collectionRef(`${path}/${name}`)
+    };
+}
+function collectionRef(path, filters = []) {
+    const children = ()=>[
+            ...fakeDocs.keys()
+        ].filter((key)=>key.startsWith(`${path}/`) && !key.slice(path.length + 1).includes('/'));
+    const query = {
+        where: (field, op, value)=>collectionRef(path, [
+                ...filters,
+                [
+                    field,
+                    op,
+                    value
+                ]
+            ]),
+        limit: ()=>query,
+        orderBy: ()=>query,
+        get: async ()=>{
+            const docs = children().filter((key)=>filters.every(([field, op, value])=>{
+                    var _fakeDocs_get;
+                    const stored = (_fakeDocs_get = fakeDocs.get(key)) == null ? void 0 : _fakeDocs_get[field];
+                    if (op === '==') return stored === value;
+                    if (op === 'array-contains') return Array.isArray(stored) && stored.includes(value);
+                    return false;
+                })).map(snapshotOf);
+            return {
+                docs,
+                empty: docs.length === 0,
+                size: docs.length
+            };
+        }
+    };
+    return _extends({}, query, {
+        path,
+        doc: (id)=>docRef(`${path}/${id != null ? id : `auto-${++autoId}`}`),
+        add: async (value)=>{
+            const ref = docRef(`${path}/auto-${++autoId}`);
+            applyWrite(ref.path, value, 'set');
+            return ref;
+        }
+    });
+}
+export const fakeFirestore = {
+    collection: (name)=>collectionRef(name),
+    runTransaction: async (fn)=>{
+        const writes = [];
+        const outcome = await fn({
+            get: (ref)=>ref.get(),
+            set: (ref, value, options)=>{
+                writes.push(()=>applyWrite(ref.path, value, (options == null ? void 0 : options.merge) ? 'merge' : 'set'));
+            },
+            update: (ref, value)=>{
+                writes.push(()=>applyWrite(ref.path, value, 'update'));
+            },
+            delete: (ref)=>{
+                writes.push(()=>fakeDocs.delete(ref.path));
+            }
+        });
+        for (const write of writes)write();
+        return outcome;
+    },
+    recursiveDelete: async (ref)=>{
+        for (const key of [
+            ...fakeDocs.keys()
+        ]){
+            if (key === ref.path || key.startsWith(`${ref.path}/`)) fakeDocs.delete(key);
+        }
+    }
+};
+export function resetFakeFirestore() {
+    fakeDocs.clear();
+    autoId = 0;
+}
+
+//# sourceMappingURL=fake-firestore.js.map

package/src/lib/testing/fake-firestore.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/commerce/src/lib/testing/fake-firestore.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * An in-memory stand-in for the Admin SDK's Firestore, for the register's\n * money-path specs (AGL-3607). Faithful where the code under test leans on\n * it: `create()` refuses an existing document, `update()` refuses a missing\n * one, merge-sets merge one level, and the `increment`, `delete` and\n * `arrayUnion` sentinels resolve against the stored value. A transaction\n * buffers its writes and applies them at commit, so a throw inside it writes\n * nothing.\n */\n\nconst INCREMENT = Symbol('increment')\nconst DELETE = Symbol('delete')\nconst UNION = Symbol('arrayUnion')\n\nexport const fakeFieldValue = {\n  increment: (value: number) => ({ [INCREMENT]: value }),\n  delete: () => ({ [DELETE]: true }),\n  arrayUnion: (...values: unknown[]) => ({ [UNION]: values }),\n  serverTimestamp: () => '<server-timestamp>',\n}\n\nexport const fakeDocs = new Map<string, Record<string, any>>()\n\nlet autoId = 0\n\nfunction resolveValue(existing: any, value: any): any {\n  if (value && typeof value === 'object') {\n    if (INCREMENT in value) return (Number(existing) || 0) + value[INCREMENT]\n    if (UNION in value) {\n      const base = Array.isArray(existing) ? [...existing] : []\n      for (const item of value[UNION]) {\n        if (!base.some((entry) => JSON.stringify(entry) === JSON.stringify(item))) base.push(item)\n      }\n      return base\n    }\n  }\n  return value\n}\n\nfunction applyWrite(\n  path: string,\n  value: Record<string, any>,\n  mode: 'set' | 'merge' | 'update',\n) {\n  const existing = fakeDocs.get(path)\n  if (mode === 'update' && !existing) {\n    const error: any = new Error(`NOT_FOUND: ${path}`)\n    error.code = 5\n    throw error\n  }\n  const next: Record<string, any> = mode === 'set' ? {} : { ...(existing ?? {}) }\n  for (const [key, raw] of Object.entries(value)) {\n    if (raw && typeof raw === 'object' && DELETE in raw) {\n      delete next[key]\n      continue\n    }\n    if (\n      mode === 'merge' &&\n      raw &&\n      typeof raw === 'object' &&\n      !Array.isArray(raw) &&\n      !(INCREMENT in raw) &&\n      !(UNION in raw) &&\n      next[key] &&\n      typeof next[key] === 'object' &&\n      !Array.isArray(next[key])\n    ) {\n      const nested = { ...next[key] }\n      for (const [inner, innerValue] of Object.entries(raw)) {\n        if (innerValue && typeof innerValue === 'object' && DELETE in (innerValue as any)) {\n          delete nested[inner]\n        } else {\n          nested[inner] = resolveValue(nested[inner], innerValue)\n        }\n      }\n      next[key] = nested\n      continue\n    }\n    next[key] = resolveValue(existing?.[key], raw)\n  }\n  fakeDocs.set(path, next)\n}\n\nfunction snapshotOf(path: string) {\n  const data = fakeDocs.get(path)\n  return {\n    id: path.split('/').pop() as string,\n    exists: data !== undefined,\n    ref: docRef(path),\n    data: () => (data ? JSON.parse(JSON.stringify(data)) : undefined),\n    get: (field: string) => data?.[field],\n  }\n}\n\nexport function docRef(path: string): any {\n  return {\n    id: path.split('/').pop() as string,\n    path,\n    get: async () => snapshotOf(path),\n    set: async (value: Record<string, any>, options?: { merge?: boolean }) =>\n      applyWrite(path, value, options?.merge ? 'merge' : 'set'),\n    update: async (value: Record<string, any>) => applyWrite(path, value, 'update'),\n    create: async (value: Record<string, any>) => {\n      if (fakeDocs.has(path)) {\n        const error: any = new Error(`ALREADY_EXISTS: ${path}`)\n        error.code = 6\n        throw error\n      }\n      applyWrite(path, value, 'set')\n    },\n    delete: async () => {\n      fakeDocs.delete(path)\n    },\n    collection: (name: string) => collectionRef(`${path}/${name}`),\n  }\n}\n\nfunction collectionRef(path: string, filters: Array<[string, string, any]> = []): any {\n  const children = () =>\n    [...fakeDocs.keys()].filter(\n      (key) => key.startsWith(`${path}/`) && !key.slice(path.length + 1).includes('/'),\n    )\n  const query = {\n    where: (field: string, op: string, value: any) =>\n      collectionRef(path, [...filters, [field, op, value]]),\n    limit: () => query,\n    orderBy: () => query,\n    get: async () => {\n      const docs = children()\n        .filter((key) =>\n          filters.every(([field, op, value]) => {\n            const stored = fakeDocs.get(key)?.[field]\n            if (op === '==') return stored === value\n            if (op === 'array-contains') return Array.isArray(stored) && stored.includes(value)\n            return false\n          }),\n        )\n        .map(snapshotOf)\n      return { docs, empty: docs.length === 0, size: docs.length }\n    },\n  }\n  return {\n    ...query,\n    path,\n    doc: (id?: string) => docRef(`${path}/${id ?? `auto-${++autoId}`}`),\n    add: async (value: Record<string, any>) => {\n      const ref = docRef(`${path}/auto-${++autoId}`)\n      applyWrite(ref.path, value, 'set')\n      return ref\n    },\n  }\n}\n\nexport const fakeFirestore: any = {\n  collection: (name: string) => collectionRef(name),\n  runTransaction: async (fn: (transaction: any) => Promise<any>) => {\n    const writes: Array<() => void> = []\n    const outcome = await fn({\n      get: (ref: any) => ref.get(),\n      set: (ref: any, value: any, options?: { merge?: boolean }) => {\n        writes.push(() => applyWrite(ref.path, value, options?.merge ? 'merge' : 'set'))\n      },\n      update: (ref: any, value: any) => {\n        writes.push(() => applyWrite(ref.path, value, 'update'))\n      },\n      delete: (ref: any) => {\n        writes.push(() => fakeDocs.delete(ref.path))\n      },\n    })\n    for (const write of writes) write()\n    return outcome\n  },\n  recursiveDelete: async (ref: any) => {\n    for (const key of [...fakeDocs.keys()]) {\n      if (key === ref.path || key.startsWith(`${ref.path}/`)) fakeDocs.delete(key)\n    }\n  },\n}\n\nexport function resetFakeFirestore(): void {\n  fakeDocs.clear()\n  autoId = 0\n}\n"],"names":["INCREMENT","Symbol","DELETE","UNION","fakeFieldValue","increment","value","delete","arrayUnion","values","serverTimestamp","fakeDocs","Map","autoId","resolveValue","existing","Number","base","Array","isArray","item","some","entry","JSON","stringify","push","applyWrite","path","mode","get","error","Error","code","next","key","raw","Object","entries","nested","inner","innerValue","set","snapshotOf","data","id","split","pop","exists","undefined","ref","docRef","parse","field","options","merge","update","create","has","collection","name","collectionRef","filters","children","keys","filter","startsWith","slice","length","includes","query","where","op","limit","orderBy","docs","every","stored","map","empty","size","doc","add","fakeFirestore","runTransaction","fn","writes","outcome","write","recursiveDelete","resetFakeFirestore","clear"],"mappings":"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"}

package/src/lib/testing/memory-firestore.d.ts

@@ -0,0 +1,136 @@
+/**
+ * @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 small in-memory stand-in for the firebase-admin Firestore surface the
+ * print queue uses (AGL-3619), for specs. Transactions are OPTIMISTIC, as
+ * Firestore's server SDK effectively is under contention: every read records
+ * the version it saw, the commit re-checks them (and re-runs any query read
+ * in the transaction), and a conflict retries the whole function. Each read
+ * yields to the event loop, so two transactions started together really do
+ * interleave, which is what a race spec needs.
+ *
+ * Supports: `collection().doc()`, `get`, `set` (with `merge`), `create`,
+ * `update`, `delete`; queries with `==`, `in` and `array-contains`, `orderBy`, `limit`,
+ * and a collection's `count()`;
+ * `runTransaction` with `get` (document or query), `set`, `update`;
+ * `batch()`. Field paths are top-level only.
+ */
+interface Stored {
+    data: Record<string, any>;
+    version: number;
+}
+export declare class MemoryFirestore {
+    readonly docs: Map<string, Stored>;
+    private autoId;
+    private clock;
+    /** Committed transactions that had to retry, for specs that assert contention happened. */
+    retries: number;
+    collection(path: string): MemoryCollection;
+    /** The document at a slash path, for assertions. */
+    read(path: string): Record<string, any> | undefined;
+    nextId(): string;
+    write(path: string, data: Record<string, any> | null): void;
+    version(path: string): number;
+    batch(): {
+        set: (ref: MemoryDoc, data: any, options?: {
+            merge?: boolean;
+        }) => number;
+        update: (ref: MemoryDoc, data: any) => number;
+        delete: (ref: MemoryDoc) => number;
+        commit: () => Promise<void>;
+    };
+    runTransaction<T>(fn: (transaction: any) => Promise<T>): Promise<T>;
+}
+export declare class MemoryCollection {
+    readonly store: MemoryFirestore;
+    readonly path: string;
+    constructor(store: MemoryFirestore, path: string);
+    doc(id?: string): MemoryDoc;
+    where(field: string, op: MemoryFilterOp, value: unknown): MemoryQuery;
+    orderBy(field: string, direction?: 'asc' | 'desc'): MemoryQuery;
+    limit(count: number): MemoryQuery;
+    /** The aggregate: its result's `data().count`. */
+    count(): MemoryQuery;
+    get(): Promise<{
+        docs: MemoryDocSnapshot[];
+        size: number;
+        empty: boolean;
+        data: () => {
+            count: number;
+        };
+    }>;
+}
+/** What a {@link MemoryDoc} read returns, shaped like a Firestore snapshot. */
+export interface MemoryDocSnapshot {
+    id: string;
+    ref: MemoryDoc;
+    exists: boolean;
+    data: () => Record<string, any> | undefined;
+    get: (field: string) => unknown;
+}
+export declare class MemoryDoc {
+    readonly store: MemoryFirestore;
+    readonly path: string;
+    constructor(store: MemoryFirestore, path: string);
+    get id(): string;
+    collection(name: string): MemoryCollection;
+    snapshot(): MemoryDocSnapshot;
+    get(): Promise<MemoryDocSnapshot>;
+    applySet(data: Record<string, any>, options?: {
+        merge?: boolean;
+    }): void;
+    applyUpdate(data: Record<string, any>): void;
+    applyCreate(data: Record<string, any>): void;
+    set(data: Record<string, any>, options?: {
+        merge?: boolean;
+    }): Promise<void>;
+    create(data: Record<string, any>): Promise<void>;
+    update(data: Record<string, any>): Promise<void>;
+    delete(): Promise<void>;
+}
+export type MemoryFilterOp = '==' | 'in' | 'array-contains';
+export declare class MemoryQuery {
+    readonly store: MemoryFirestore;
+    readonly path: string;
+    private filters;
+    private order;
+    private max;
+    constructor(store: MemoryFirestore, path: string);
+    private clone;
+    where(field: string, op: MemoryFilterOp, value: unknown): MemoryQuery;
+    orderBy(field: string, direction?: 'asc' | 'desc'): MemoryQuery;
+    limit(count: number): MemoryQuery;
+    run(): {
+        docs: MemoryDocSnapshot[];
+        size: number;
+        empty: boolean;
+        data: () => {
+            count: number;
+        };
+    };
+    /** The paths and versions this query matches now, to detect a changed result. */
+    signature(): string;
+    get(): Promise<{
+        docs: MemoryDocSnapshot[];
+        size: number;
+        empty: boolean;
+        data: () => {
+            count: number;
+        };
+    }>;
+}
+export {};

package/src/lib/testing/memory-firestore.js

@@ -0,0 +1,282 @@
+/**
+ * @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 small in-memory stand-in for the firebase-admin Firestore surface the
+ * print queue uses (AGL-3619), for specs. Transactions are OPTIMISTIC, as
+ * Firestore's server SDK effectively is under contention: every read records
+ * the version it saw, the commit re-checks them (and re-runs any query read
+ * in the transaction), and a conflict retries the whole function. Each read
+ * yields to the event loop, so two transactions started together really do
+ * interleave, which is what a race spec needs.
+ *
+ * Supports: `collection().doc()`, `get`, `set` (with `merge`), `create`,
+ * `update`, `delete`; queries with `==`, `in` and `array-contains`, `orderBy`, `limit`,
+ * and a collection's `count()`;
+ * `runTransaction` with `get` (document or query), `set`, `update`;
+ * `batch()`. Field paths are top-level only.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+const tick = ()=>new Promise((resolve)=>setTimeout(resolve, 0));
+export class MemoryFirestore {
+    collection(path) {
+        return new MemoryCollection(this, path);
+    }
+    /** The document at a slash path, for assertions. */ read(path) {
+        const stored = this.docs.get(path);
+        return stored ? _extends({}, stored.data) : undefined;
+    }
+    nextId() {
+        this.autoId += 1;
+        return `auto${String(this.autoId).padStart(4, '0')}`;
+    }
+    write(path, data) {
+        this.clock += 1;
+        if (data === null) this.docs.delete(path);
+        else this.docs.set(path, {
+            data: _extends({}, data),
+            version: this.clock
+        });
+    }
+    version(path) {
+        var _ref;
+        var _this_docs_get;
+        return (_ref = (_this_docs_get = this.docs.get(path)) == null ? void 0 : _this_docs_get.version) != null ? _ref : 0;
+    }
+    batch() {
+        const ops = [];
+        return {
+            set: (ref, data, options)=>ops.push(()=>ref.applySet(data, options)),
+            update: (ref, data)=>ops.push(()=>ref.applyUpdate(data)),
+            delete: (ref)=>ops.push(()=>this.write(ref.path, null)),
+            commit: async ()=>{
+                await tick();
+                for (const op of ops)op();
+            }
+        };
+    }
+    async runTransaction(fn) {
+        for(let attempt = 0; attempt < 10; attempt += 1){
+            const seen = new Map();
+            const queries = [];
+            const writes = [];
+            const transaction = {
+                get: async (target)=>{
+                    await tick();
+                    if (target instanceof MemoryDoc) {
+                        seen.set(target.path, this.version(target.path));
+                        return target.snapshot();
+                    }
+                    const result = target.run();
+                    queries.push({
+                        query: target,
+                        snapshot: target.signature()
+                    });
+                    for (const doc of result.docs)seen.set(doc.ref.path, this.version(doc.ref.path));
+                    return result;
+                },
+                set: (ref, data, options)=>{
+                    writes.push(()=>ref.applySet(data, options));
+                    return transaction;
+                },
+                update: (ref, data)=>{
+                    writes.push(()=>ref.applyUpdate(data));
+                    return transaction;
+                },
+                create: (ref, data)=>{
+                    writes.push(()=>ref.applyCreate(data));
+                    return transaction;
+                }
+            };
+            const result = await fn(transaction);
+            await tick();
+            const conflicted = [
+                ...seen
+            ].some(([path, version])=>this.version(path) !== version) || queries.some(({ query, snapshot })=>query.signature() !== snapshot);
+            if (conflicted) {
+                this.retries += 1;
+                continue;
+            }
+            for (const write of writes)write();
+            return result;
+        }
+        throw new Error('transaction contention: too many retries');
+    }
+    constructor(){
+        this.docs = new Map();
+        this.autoId = 0;
+        this.clock = 0;
+        /** Committed transactions that had to retry, for specs that assert contention happened. */ this.retries = 0;
+    }
+}
+export class MemoryCollection {
+    doc(id) {
+        return new MemoryDoc(this.store, `${this.path}/${id != null ? id : this.store.nextId()}`);
+    }
+    where(field, op, value) {
+        return new MemoryQuery(this.store, this.path).where(field, op, value);
+    }
+    orderBy(field, direction = 'asc') {
+        return new MemoryQuery(this.store, this.path).orderBy(field, direction);
+    }
+    limit(count) {
+        return new MemoryQuery(this.store, this.path).limit(count);
+    }
+    /** The aggregate: its result's `data().count`. */ count() {
+        return new MemoryQuery(this.store, this.path);
+    }
+    get() {
+        return Promise.resolve(new MemoryQuery(this.store, this.path).run());
+    }
+    constructor(store, path){
+        this.store = store;
+        this.path = path;
+    }
+}
+export class MemoryDoc {
+    get id() {
+        var _this_path_split_pop;
+        return (_this_path_split_pop = this.path.split('/').pop()) != null ? _this_path_split_pop : '';
+    }
+    collection(name) {
+        return new MemoryCollection(this.store, `${this.path}/${name}`);
+    }
+    snapshot() {
+        const stored = this.store.docs.get(this.path);
+        const data = stored ? _extends({}, stored.data) : undefined;
+        return {
+            id: this.id,
+            ref: this,
+            exists: Boolean(stored),
+            data: ()=>data ? _extends({}, data) : undefined,
+            get: (field)=>data == null ? void 0 : data[field]
+        };
+    }
+    async get() {
+        await tick();
+        return this.snapshot();
+    }
+    applySet(data, options) {
+        var _this_store_docs_get;
+        const previous = (_this_store_docs_get = this.store.docs.get(this.path)) == null ? void 0 : _this_store_docs_get.data;
+        this.store.write(this.path, (options == null ? void 0 : options.merge) && previous ? _extends({}, previous, data) : data);
+    }
+    applyUpdate(data) {
+        var _this_store_docs_get;
+        const previous = (_this_store_docs_get = this.store.docs.get(this.path)) == null ? void 0 : _this_store_docs_get.data;
+        if (!previous) throw Object.assign(new Error('NOT_FOUND'), {
+            code: 5
+        });
+        this.store.write(this.path, _extends({}, previous, data));
+    }
+    applyCreate(data) {
+        if (this.store.docs.has(this.path)) {
+            throw Object.assign(new Error('Document already exists'), {
+                code: 6
+            });
+        }
+        this.store.write(this.path, data);
+    }
+    async set(data, options) {
+        await tick();
+        this.applySet(data, options);
+    }
+    async create(data) {
+        await tick();
+        this.applyCreate(data);
+    }
+    async update(data) {
+        await tick();
+        this.applyUpdate(data);
+    }
+    async delete() {
+        await tick();
+        this.store.write(this.path, null);
+    }
+    constructor(store, path){
+        this.store = store;
+        this.path = path;
+    }
+}
+export class MemoryQuery {
+    clone() {
+        const next = new MemoryQuery(this.store, this.path);
+        next.filters = [
+            ...this.filters
+        ];
+        next.order = this.order;
+        next.max = this.max;
+        return next;
+    }
+    where(field, op, value) {
+        const next = this.clone();
+        next.filters.push({
+            field,
+            op,
+            value
+        });
+        return next;
+    }
+    orderBy(field, direction = 'asc') {
+        const next = this.clone();
+        next.order = {
+            field,
+            direction
+        };
+        return next;
+    }
+    limit(count) {
+        const next = this.clone();
+        next.max = count;
+        return next;
+    }
+    run() {
+        const prefix = `${this.path}/`;
+        let rows = [
+            ...this.store.docs.entries()
+        ].filter(([path])=>path.startsWith(prefix) && !path.slice(prefix.length).includes('/')).filter(([, stored])=>this.filters.every(({ field, op, value })=>op === 'in' ? value.includes(stored.data[field]) : op === 'array-contains' ? Array.isArray(stored.data[field]) && stored.data[field].includes(value) : stored.data[field] === value));
+        if (this.order) {
+            const { field, direction } = this.order;
+            rows = rows.sort(([, a], [, b])=>{
+                const delta = a.data[field] < b.data[field] ? -1 : a.data[field] > b.data[field] ? 1 : 0;
+                return direction === 'asc' ? delta : -delta;
+            });
+        }
+        const docs = rows.slice(0, this.max).map(([path])=>new MemoryDoc(this.store, path).snapshot());
+        // `data()` answers a `count()` aggregate read through the same query.
+        return {
+            docs,
+            size: docs.length,
+            empty: docs.length === 0,
+            data: ()=>({
+                    count: docs.length
+                })
+        };
+    }
+    /** The paths and versions this query matches now, to detect a changed result. */ signature() {
+        return this.run().docs.map((doc)=>`${doc.ref.path}@${this.store.version(doc.ref.path)}`).join('|');
+    }
+    get() {
+        return tick().then(()=>this.run());
+    }
+    constructor(store, path){
+        this.store = store;
+        this.path = path;
+        this.filters = [];
+        this.order = null;
+        this.max = Infinity;
+    }
+}
+
+//# sourceMappingURL=memory-firestore.js.map