@antelopejs/interface-database 0.1.6 → 0.1.8

package/dist/staged-query/common.d.ts

@@ -0,0 +1,58 @@
+import type { Datum } from "./datum";
+import type { Query } from "./query";
+import type { ValueProxy, ValueProxyOrValue } from "./valueproxy";
+export type StagedConstructor<T extends StagedObject = StagedObject> = new (newStage: QueryStage, previous?: StagedObject) => T;
+/**
+ * Recursive Partial generic type
+ */
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends Array<infer U1> ? Array<DeepPartial<U1>> : T[K] extends ReadonlyArray<infer U2> ? ReadonlyArray<DeepPartial<U2>> : DeepPartial<T[K]>;
+};
+/**
+ * Change event
+ */
+export interface Changes<T> {
+    /**
+     * The type of change that occured
+     *
+     * Possible values: added, removed, modified
+     */
+    changeType: "added" | "removed" | "modified";
+    /**
+     * Value prior to the change
+     */
+    oldValue?: T;
+    /**
+     * New value after the change
+     */
+    newValue?: T;
+}
+export interface InsertOptions {
+    conflict?: "update" | "replace";
+}
+export interface QueryStage {
+    stage: string;
+    options?: any;
+    args: any[];
+}
+export declare function QueryStage(stage: string, options?: any, ...args: any[]): {
+    stage: string;
+    options: any;
+    args: any[];
+};
+export declare class StagedObject {
+    protected readonly stages: QueryStage[];
+    constructor(newStage: QueryStage, previous?: StagedObject);
+    build(): QueryStage[];
+    protected stage(type: undefined, stage: string, options?: any, ...args: any[]): this;
+    protected stage<T extends StagedObject>(type: StagedConstructor<T>, stage: string, options?: any, ...args: any[]): T;
+    private static nextargid;
+    protected callfunc<T extends StagedObject[]>(func: (...args: T) => any, ...args: (typeof StagedObject)[]): QueryStage;
+}
+export type Value<T> = Datum<T> | ValueProxyOrValue<T>;
+type UnknownObject = Record<keyof any, unknown>;
+type ExtractTypeObject<T extends UnknownObject> = T extends infer O ? {
+    [K in keyof O]: ExtractType<O[K]>;
+} : never;
+export type ExtractType<T> = T extends ValueProxy<infer A> ? A : T extends Query<infer A> ? A : T extends UnknownObject ? ExtractTypeObject<T> : T extends Array<infer A> ? Array<ExtractType<A>> : T;
+export {};

package/dist/staged-query/common.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StagedObject = void 0;
+exports.QueryStage = QueryStage;
+function QueryStage(stage, options, ...args) {
+    return {
+        stage,
+        options,
+        args,
+    };
+}
+class StagedObject {
+    stages;
+    constructor(newStage, previous) {
+        this.stages = previous ? [...previous.stages, newStage] : [newStage];
+    }
+    //@internal
+    build() {
+        return this.stages;
+    }
+    stage(type, stage, options, ...args) {
+        const Constructor = type ?? this.constructor;
+        return new Constructor({
+            stage,
+            options,
+            args,
+        }, this);
+    }
+    static nextargid = 0;
+    callfunc(func, ...args) {
+        const argNumbers = [];
+        const argValues = [];
+        for (let i = 0; i < args.length; ++i) {
+            const id = StagedObject.nextargid++;
+            argNumbers[i] = id;
+            argValues[i] = new args[i](QueryStage("arg", undefined, id));
+        }
+        return {
+            stage: "func", // TODO: using the query stage structure here doesnt make any sense
+            args: [argNumbers, func(...argValues)],
+        };
+    }
+}
+exports.StagedObject = StagedObject;
+//# sourceMappingURL=common.js.map

package/dist/staged-query/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/staged-query/common.ts"],"names":[],"mappings":";;;AAoDA,gCAMC;AAND,SAAgB,UAAU,CAAC,KAAa,EAAE,OAAa,EAAE,GAAG,IAAW;IACrE,OAAO;QACL,KAAK;QACL,OAAO;QACP,IAAI;KACL,CAAC;AACJ,CAAC;AAED,MAAa,YAAY;IACJ,MAAM,CAAe;IAExC,YAAmB,QAAoB,EAAE,QAAuB;QAC9D,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACvE,CAAC;IAED,WAAW;IACJ,KAAK;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAcS,KAAK,CACb,IAAsC,EACtC,KAAa,EACb,OAAa,EACb,GAAG,IAAW;QAEd,MAAM,WAAW,GAAG,IAAI,IAAK,IAAI,CAAC,WAAoC,CAAC;QACvE,OAAO,IAAI,WAAW,CACpB;YACE,KAAK;YACL,OAAO;YACP,IAAI;SACL,EACD,IAAI,CACL,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC;IACnB,QAAQ,CAChB,IAAyB,EACzB,GAAG,IAA6B;QAEhC,MAAM,UAAU,GAAa,EAAE,CAAC;QAChC,MAAM,SAAS,GAAmB,EAAE,CAAC;QACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACrC,MAAM,EAAE,GAAG,YAAY,CAAC,SAAS,EAAE,CAAC;YACpC,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YACnB,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC;QAC/D,CAAC;QACD,OAAO;YACL,KAAK,EAAE,MAAM,EAAE,mEAAmE;YAClF,IAAI,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,GAAI,SAAe,CAAC,CAAC;SAC9C,CAAC;IACJ,CAAC;;AAzDH,oCA0DC"}

package/dist/staged-query/datum.d.ts

@@ -0,0 +1,55 @@
+import { Query } from "./query";
+import { ValueProxy } from "./valueproxy";
+import type { Selection } from "./selection";
+import type { ExtractType, Value } from "./common";
+export declare class Datum<T> extends Query<T> {
+    /**
+     * Changes the type of this datum.
+     * This does not actually perform any conversion, it only changes the typescript type.
+     *
+     * @returns Same datum with a different type
+     */
+    cast<U>(): Datum<U>;
+    /**
+     * Indexes the datum.
+     *
+     * TODO: Better name?
+     * TODO: typing for compound keys (a.b.c)
+     *
+     * @param key Field name
+     * @param def Default value
+     * @returns New datum with the value
+     */
+    key<K extends keyof NonNullable<T>, U = undefined>(key: K, def?: U): Datum<U extends undefined ? NonNullable<T>[K] : U | NonNullable<NonNullable<T>[K]>>;
+    /**
+     * Defaults the datum to a given value if it is null.
+     *
+     * @param value Default value
+     * @returns Current datum or given value
+     */
+    default<U>(val: Value<U>): Datum<U | Exclude<T, null | undefined>>;
+    /**
+     * Run a mapping function on the datum.
+     *
+     * @param mapper Mapping function
+     * @returns New datum with the result of the mapper
+     */
+    do<U>(mapper: (val: ValueProxy<T>) => U): Datum<ExtractType<U>>;
+    /**
+     * Perform a foreign key lookup
+     *
+     * @param other Other table
+     * @param localKey Key in local object
+     * @param otherKey Key in other table
+     */
+    lookup<U = any, TK extends keyof T = keyof T>(other: Selection<U>, localKey: TK, otherKey: keyof U): Datum<Omit<T, TK> & Record<TK, T[TK] extends any[] ? U[] : U>>;
+    /**
+     * Plucks fields from the documents.
+     *
+     * TODO: Better typing
+     *
+     * @param fields Fields to keep
+     * @returns New datum
+     */
+    pluck(...fields: string[]): Datum<Partial<T>>;
+}

package/dist/staged-query/datum.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Datum = void 0;
+const query_1 = require("./query");
+const valueproxy_1 = require("./valueproxy");
+class Datum extends query_1.Query {
+    /**
+     * Changes the type of this datum.
+     * This does not actually perform any conversion, it only changes the typescript type.
+     *
+     * @returns Same datum with a different type
+     */
+    cast() {
+        return this;
+    }
+    /**
+     * Indexes the datum.
+     *
+     * TODO: Better name?
+     * TODO: typing for compound keys (a.b.c)
+     *
+     * @param key Field name
+     * @param def Default value
+     * @returns New datum with the value
+     */
+    key(key, def) {
+        return this.stage((Datum), "key", undefined, key, def);
+    }
+    /**
+     * Defaults the datum to a given value if it is null.
+     *
+     * @param value Default value
+     * @returns Current datum or given value
+     */
+    default(val) {
+        return this.stage((Datum), "default", undefined, val);
+    }
+    /**
+     * Run a mapping function on the datum.
+     *
+     * @param mapper Mapping function
+     * @returns New datum with the result of the mapper
+     */
+    do(mapper) {
+        return this.stage((Datum), "map", undefined, this.callfunc(mapper, (valueproxy_1.ValueProxy)));
+    }
+    /**
+     * Perform a foreign key lookup
+     *
+     * @param other Other table
+     * @param localKey Key in local object
+     * @param otherKey Key in other table
+     */
+    lookup(other, localKey, otherKey) {
+        return this.stage((Datum), "lookup", { localKey, otherKey }, other);
+    }
+    /**
+     * Plucks fields from the documents.
+     *
+     * TODO: Better typing
+     *
+     * @param fields Fields to keep
+     * @returns New datum
+     */
+    pluck(...fields) {
+        return this.stage((Datum), "pluck", undefined, fields);
+    }
+}
+exports.Datum = Datum;
+//# sourceMappingURL=datum.js.map

package/dist/staged-query/datum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datum.js","sourceRoot":"","sources":["../../src/staged-query/datum.ts"],"names":[],"mappings":";;;AAAA,mCAAgC;AAChC,6CAA0C;AAI1C,MAAa,KAAS,SAAQ,aAAQ;IACpC;;;;;OAKG;IACI,IAAI;QACT,OAAO,IAA2B,CAAC;IACrC,CAAC;IAED;;;;;;;;;OASG;IACI,GAAG,CAAgD,GAAM,EAAE,GAAO;QACvE,OAAO,IAAI,CAAC,KAAK,CACf,CAAA,KAIC,CAAA,EACD,KAAK,EACL,SAAS,EACT,GAAG,EACH,GAAG,CACJ,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACI,OAAO,CAAI,GAAa;QAC7B,OAAO,IAAI,CAAC,KAAK,CACf,CAAA,KAAuC,CAAA,EACvC,SAAS,EACT,SAAS,EACT,GAAG,CACJ,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACI,EAAE,CAAI,MAAiC;QAC5C,OAAO,IAAI,CAAC,KAAK,CACf,CAAA,KAAqB,CAAA,EACrB,KAAK,EACL,SAAS,EACT,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAA,uBAAa,CAAA,CAAC,CACrC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CACX,KAAmB,EACnB,QAAY,EACZ,QAAiB;QAEjB,OAAO,IAAI,CAAC,KAAK,CACf,CAAA,KAA8D,CAAA,EAC9D,QAAQ,EACR,EAAE,QAAQ,EAAE,QAAQ,EAAE,EACtB,KAAK,CACN,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,GAAG,MAAgB;QAC9B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA,KAAiB,CAAA,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC;CACF;AAhGD,sBAgGC"}

package/dist/staged-query/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./common";
+export * from "./atomic";
+export { Datum } from "./datum";
+export { Query } from "./query";
+export { CROSS_INSTANCE, Schema, SchemaInstance, type FieldType, type IndexDefinition, type InstanceId, type SchemaDefinition, type StringFieldType, type TableDefinition, } from "./schema";
+export { Selection, SingleSelection, Table } from "./selection";
+export { Stream } from "./stream";
+export { ValueProxy, type ValueProxyOrValue } from "./valueproxy";

package/dist/staged-query/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueProxy = exports.Stream = exports.Table = exports.SingleSelection = exports.Selection = exports.SchemaInstance = exports.Schema = exports.CROSS_INSTANCE = exports.Query = exports.Datum = void 0;
+__exportStar(require("./common"), exports);
+__exportStar(require("./atomic"), exports);
+var datum_1 = require("./datum");
+Object.defineProperty(exports, "Datum", { enumerable: true, get: function () { return datum_1.Datum; } });
+var query_1 = require("./query");
+Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return query_1.Query; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "CROSS_INSTANCE", { enumerable: true, get: function () { return schema_1.CROSS_INSTANCE; } });
+Object.defineProperty(exports, "Schema", { enumerable: true, get: function () { return schema_1.Schema; } });
+Object.defineProperty(exports, "SchemaInstance", { enumerable: true, get: function () { return schema_1.SchemaInstance; } });
+var selection_1 = require("./selection");
+Object.defineProperty(exports, "Selection", { enumerable: true, get: function () { return selection_1.Selection; } });
+Object.defineProperty(exports, "SingleSelection", { enumerable: true, get: function () { return selection_1.SingleSelection; } });
+Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return selection_1.Table; } });
+var stream_1 = require("./stream");
+Object.defineProperty(exports, "Stream", { enumerable: true, get: function () { return stream_1.Stream; } });
+var valueproxy_1 = require("./valueproxy");
+Object.defineProperty(exports, "ValueProxy", { enumerable: true, get: function () { return valueproxy_1.ValueProxy; } });
+//# sourceMappingURL=index.js.map

package/dist/staged-query/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/staged-query/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,2CAAyB;AACzB,iCAAgC;AAAvB,8FAAA,KAAK,OAAA;AACd,iCAAgC;AAAvB,8FAAA,KAAK,OAAA;AACd,mCAUkB;AAThB,wGAAA,cAAc,OAAA;AACd,gGAAA,MAAM,OAAA;AACN,wGAAA,cAAc,OAAA;AAQhB,yCAAgE;AAAvD,sGAAA,SAAS,OAAA;AAAE,4GAAA,eAAe,OAAA;AAAE,kGAAA,KAAK,OAAA;AAC1C,mCAAkC;AAAzB,gGAAA,MAAM,OAAA;AACf,2CAAkE;AAAzD,wGAAA,UAAU,OAAA"}

package/dist/staged-query/query.d.ts

@@ -0,0 +1,3 @@
+import { StagedObject } from "./common";
+export declare class Query<T> extends StagedObject {
+}

package/dist/staged-query/query.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const common_1 = require("./common");
+// oxlint-disable-next-line typescript/no-unused-vars -- The executable entry consumes T through declaration merging.
+class Query extends common_1.StagedObject {
+}
+exports.Query = Query;
+//# sourceMappingURL=query.js.map

package/dist/staged-query/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/staged-query/query.ts"],"names":[],"mappings":";;;AAAA,qCAAwC;AAExC,qHAAqH;AACrH,MAAa,KAAS,SAAQ,qBAAY;CAAG;AAA7C,sBAA6C"}

package/dist/staged-query/schema.d.ts

@@ -0,0 +1,137 @@
+import { Query } from "./query";
+import { Table } from "./selection";
+import { StagedObject } from "./common";
+/**
+ * Secondary table index definition
+ */
+export interface IndexDefinition {
+    /**
+     * Fields to use for compound indexes
+     */
+    fields?: string[];
+    /**
+     * Whether or not this is a multi index
+     */
+    multi?: boolean;
+    /**
+     * Whether this index must also serve queries that run across all instances
+     * ({@link CROSS_INSTANCE})
+     *
+     * When `true`, the driver also maintains an index usable by cross-instance
+     * queries. Defaults to `false`: the index is optimized for queries scoped to
+     * one instance, and cross-instance queries using it may be slow.
+     *
+     * This flag never changes query results, only performance.
+     */
+    crossInstance?: boolean;
+}
+export type StringFieldType = string | Array<StringFieldType> | {
+    [subfield: string]: StringFieldType;
+};
+interface IoTsCodec {
+    readonly _A: unknown;
+    readonly _O: unknown;
+    readonly _I: unknown;
+    readonly name: string;
+    is(u: unknown): boolean;
+    encode(a: never): unknown;
+    decode(i: unknown): unknown;
+}
+export type FieldType = StringFieldType | IoTsCodec;
+/**
+ * Schema table definition
+ */
+export interface TableDefinition {
+    /**
+     * Field names and their data types
+     */
+    fields: Record<string, FieldType>;
+    /**
+     * List of secondary indexes
+     */
+    indexes: Record<string, IndexDefinition>;
+}
+/**
+ * Table names and their definitions
+ */
+export interface SchemaDefinition {
+    [tableName: string]: TableDefinition;
+}
+/**
+ * Sentinel instance id meaning "operate across all instances of the schema".
+ *
+ * Secondary indexes are optimized for queries scoped to one instance; set
+ * {@link IndexDefinition.crossInstance} on the indexes that cross-instance
+ * queries rely on.
+ */
+export declare const CROSS_INSTANCE: unique symbol;
+/**
+ * Instance identifier accepted by {@link Schema.instance}.
+ */
+export type InstanceId = string | typeof CROSS_INSTANCE;
+/**
+ * A schema determines the structure of a database
+ *
+ * Each schema can have multiple instances. The internal organization of these
+ * instances is left up to the module implementation.
+ */
+export declare class Schema<T = any, Definition = SchemaDefinition> extends StagedObject {
+    readonly id: string;
+    readonly definition: Definition;
+    private static readonly registry;
+    /**
+     * Retrieves a previously defined schema by its ID
+     *
+     * @param id Schema ID
+     * @returns The schema instance, or undefined if not found
+     */
+    static get<T = any, Definition = SchemaDefinition>(id: string): Schema<T, Definition> | undefined;
+    /**
+     * Define a new schema with the given ID
+     *
+     * @param id ID of this schema, changing this will leave previous data inaccessible
+     * @param definition Schema definition (tables, fields, indexes..)
+     */
+    constructor(id: string, definition: Definition);
+    /**
+     * Gets a specific instance of the schema
+     *
+     * @param id Instance ID, or {@link CROSS_INSTANCE} for a cross-instance query
+     * @returns Schema instance
+     */
+    instance(id?: InstanceId): SchemaInstance<T>;
+    /**
+     * Creates a new instance of the schema
+     *
+     * @param id Instance ID
+     * @returns Created instance ID
+     */
+    createInstance(id?: string): Query<string>;
+    /**
+     * Destroys an existing instance of the schema
+     *
+     * @param id Instance ID
+     */
+    destroyInstance(id?: string): Query<void>;
+    /**
+     * Lists the IDs of named instances of this schema.
+     *
+     * The default (unnamed) instance is not included.
+     *
+     * @returns IDs of named instances of this schema
+     */
+    listInstances(): Query<string[]>;
+}
+/**
+ * Schema instance, could be a database or a filtered portion of one depending on the implementation
+ */
+export declare class SchemaInstance<T> extends StagedObject {
+    /**
+     * Gets a table from the instance
+     *
+     * @param id Table name
+     * @returns Table
+     */
+    table<TK extends keyof T>(id: TK): Table<T[TK]>;
+}
+export {};

package/dist/staged-query/schema.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaInstance = exports.Schema = exports.CROSS_INSTANCE = void 0;
+const query_1 = require("./query");
+const selection_1 = require("./selection");
+const common_1 = require("./common");
+/**
+ * Sentinel instance id meaning "operate across all instances of the schema".
+ *
+ * Secondary indexes are optimized for queries scoped to one instance; set
+ * {@link IndexDefinition.crossInstance} on the indexes that cross-instance
+ * queries rely on.
+ */
+exports.CROSS_INSTANCE = Symbol("antelopejs:cross-instance");
+/**
+ * A schema determines the structure of a database
+ *
+ * Each schema can have multiple instances. The internal organization of these
+ * instances is left up to the module implementation.
+ */
+class Schema extends common_1.StagedObject {
+    id;
+    definition;
+    static registry = new Map();
+    /**
+     * Retrieves a previously defined schema by its ID
+     *
+     * @param id Schema ID
+     * @returns The schema instance, or undefined if not found
+     */
+    static get(id) {
+        return Schema.registry.get(id);
+    }
+    /**
+     * Define a new schema with the given ID
+     *
+     * @param id ID of this schema, changing this will leave previous data inaccessible
+     * @param definition Schema definition (tables, fields, indexes..)
+     */
+    constructor(id, definition) {
+        super((0, common_1.QueryStage)("schema", { id }));
+        this.id = id;
+        this.definition = definition;
+        Schema.registry.set(id, this);
+    }
+    /**
+     * Gets a specific instance of the schema
+     *
+     * @param id Instance ID, or {@link CROSS_INSTANCE} for a cross-instance query
+     * @returns Schema instance
+     */
+    instance(id) {
+        return this.stage((SchemaInstance), "instance", { id });
+    }
+    /**
+     * Creates a new instance of the schema
+     *
+     * @param id Instance ID
+     * @returns Created instance ID
+     */
+    createInstance(id) {
+        return this.stage((query_1.Query), "createInstance", { id });
+    }
+    /**
+     * Destroys an existing instance of the schema
+     *
+     * @param id Instance ID
+     */
+    destroyInstance(id) {
+        return this.stage((query_1.Query), "destroyInstance", { id });
+    }
+    /**
+     * Lists the IDs of named instances of this schema.
+     *
+     * The default (unnamed) instance is not included.
+     *
+     * @returns IDs of named instances of this schema
+     */
+    listInstances() {
+        return this.stage((query_1.Query), "listInstances");
+    }
+}
+exports.Schema = Schema;
+/**
+ * Schema instance, could be a database or a filtered portion of one depending on the implementation
+ */
+class SchemaInstance extends common_1.StagedObject {
+    /**
+     * Gets a table from the instance
+     *
+     * @param id Table name
+     * @returns Table
+     */
+    table(id) {
+        return this.stage((selection_1.Table), "table", { id });
+    }
+}
+exports.SchemaInstance = SchemaInstance;
+//# sourceMappingURL=schema.js.map

package/dist/staged-query/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/staged-query/schema.ts"],"names":[],"mappings":";;;AAAA,mCAAgC;AAChC,2CAAoC;AACpC,qCAAoD;AAoEpD;;;;;;GAMG;AACU,QAAA,cAAc,GAAkB,MAAM,CACjD,2BAA2B,CAC5B,CAAC;AAOF;;;;;GAKG;AACH,MAAa,MAGX,SAAQ,qBAAY;IAsBF;IACA;IAtBV,MAAM,CAAU,QAAQ,GAAG,IAAI,GAAG,EAAgC,CAAC;IAE3E;;;;;OAKG;IACI,MAAM,CAAC,GAAG,CACf,EAAU;QAEV,OAAO,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAsC,CAAC;IACtE,CAAC;IAED;;;;;OAKG;IACH,YACkB,EAAU,EACV,UAAsB;QAEtC,KAAK,CAAC,IAAA,mBAAU,EAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QAHpB,OAAE,GAAF,EAAE,CAAQ;QACV,eAAU,GAAV,UAAU,CAAY;QAGtC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,EAAe;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA,cAAiB,CAAA,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACI,cAAc,CAAC,EAAW;QAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA,aAAa,CAAA,EAAE,gBAAgB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,EAAW;QAChC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA,aAAW,CAAA,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;OAMG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA,aAAe,CAAA,EAAE,eAAe,CAAC,CAAC;IACtD,CAAC;;AAtEH,wBAuEC;AAED;;GAEG;AACH,MAAa,cAAkB,SAAQ,qBAAY;IACjD;;;;;OAKG;IACI,KAAK,CAAqB,EAAM;QACrC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA,iBAAY,CAAA,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACnD,CAAC;CACF;AAVD,wCAUC"}

package/dist/staged-query/selection.d.ts

@@ -0,0 +1,104 @@
+import { Datum } from "./datum";
+import { Query } from "./query";
+import { Stream } from "./stream";
+import { ValueProxy, type ValueProxyOrValue } from "./valueproxy";
+import type { Changes, DeepPartial, ExtractType, InsertOptions } from "./common";
+import { type AtomicMutation, type AtomicMutationOutcome } from "./atomic";
+type SelectionKey = string | number | boolean;
+/**
+ * Selection containing a single element
+ */
+export declare class SingleSelection<T> extends Datum<T> {
+    /**
+     * Update fields of this selection with the given values
+     *
+     * @param document Partial document with new values
+     * @returns Number of modified documents
+     */
+    update(document: DeepPartial<T>): Query<number>;
+    update<U>(document: (val: ValueProxy<T>) => U): ExtractType<U> extends DeepPartial<T> ? Query<number> : never;
+    /**
+     * Replace documents of this selection
+     *
+     * @param document Partial document to replace with
+     * @returns Number of modified documents
+     */
+    replace(document: DeepPartial<T>): Query<number>;
+    /**
+     * Delete selected documents
+     *
+     * @returns Number of deleted documents
+     */
+    delete(): Query<number>;
+    /**
+     * Turns this selection into a change feed
+     *
+     * @returns Change feed
+     */
+    changes(): Query<Changes<T>[]>;
+}
+/**
+ * Selection containing any number of elements
+ */
+export declare class Selection<T> extends Stream<T> {
+    /**
+     * Update fields of this selection with the given values
+     *
+     * @param document Partial document with new values
+     * @returns Number of modified documents
+     */
+    update(document: DeepPartial<T>): Query<number>;
+    update<U>(document: (val: ValueProxy<T>) => U): ExtractType<U> extends DeepPartial<T> ? Query<number> : never;
+    /**
+     * Replace documents of this selection
+     *
+     * @param document Partial document to replace with
+     * @returns Number of modified documents
+     */
+    replace(document: DeepPartial<T>): Query<number>;
+    /**
+     * Delete selected documents
+     *
+     * @returns Number of deleted documents
+     */
+    delete(): Query<number>;
+}
+/**
+ * Database table
+ */
+export declare class Table<T> extends Selection<T> {
+    /** Atomically checks one record's revision and patches or deletes it without upsert. */
+    atomicMutation(key: string, request: AtomicMutation<T>): Query<AtomicMutationOutcome>;
+    /**
+     * Inserts one or more documents into this table
+     *
+     * @param obj Document(s) to insert
+     * @returns Inserted IDs
+     */
+    insert(obj: DeepPartial<T> | DeepPartial<T>[], options?: InsertOptions): Query<string[]>;
+    /**
+     * Gets a document using its primary key
+     *
+     * @param key Primary key value
+     * @returns Single document selection
+     */
+    get(key: ValueProxyOrValue<string>): SingleSelection<T>;
+    /**
+     * Gets multiple documents using a secondary index
+     *
+     * @param keys Key value(s)
+     * @param index Secondary index, will use the primary key if undefined
+     * @returns Multiple document selection
+     */
+    getAll(keys: ValueProxyOrValue<SelectionKey> | ValueProxyOrValue<SelectionKey>[], index?: string): Selection<T>;
+    /**
+     * Gets multiple documents using a secondary index and bounding values
+     *
+     * @param index Secondary index
+     * @param low Lowest value of the range
+     * @param high Highest value of the range (excluded)
+     * @returns Multiple document selection
+     */
+    between<TK extends keyof T>(index: TK, low: T[TK], high: T[TK]): Selection<T>;
+}
+export {};