sorodb 0.0.0

package/types/index-methods.d.ts

@@ -0,0 +1,16 @@
+/** @param {unknown} value */
+declare function supportsBtreeValue(value: unknown): boolean;
+/** @param {unknown} value @param {import("./types.js").Direction} [direction] */
+declare function btreeScalar(value: unknown, direction?: import("./types.js").Direction): Buffer<ArrayBuffer>;
+/** @param {string} name */
+export declare function indexMethod(name: string): {
+    supportsValue: typeof supportsBtreeValue;
+    encodeValue: typeof btreeScalar;
+    /** @param {import("./types.js").Index} index @param {import("./types.js").IndexField[]} order */
+    supportsOrder: (index: import("./types.js").Index, order: import("./types.js").IndexField[]) => boolean;
+    /** @param {string} table @param {import("./types.js").Index} index @param {string} path @param {unknown} value */
+    equalityPrefix(table: string, index: import("./types.js").Index, path: string, value: unknown): Buffer<ArrayBuffer> | null;
+};
+/** @param {string} table @param {import("./types.js").Index} index @param {import("./types.js").Document} doc */
+export declare function indexKey(table: string, index: import("./types.js").Index, doc: import("./types.js").Document): Buffer<ArrayBuffer> | null;
+export {};

package/types/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Database } from "./storage.js";
+/** @param {import("./types.js").DatabaseConfig} config */
+export default function SoroDB(config: import("./types.js").DatabaseConfig): Database;
+export { SoroDB };
+export { SoroError, ValidationError, SchemaError, ConflictError, QueryError, CursorError, } from "./errors.js";

package/types/indexes.d.ts

@@ -0,0 +1,4 @@
+/** @param {import("@slatedb/uniffi").DbTransaction} tx @param {import("./types.js").Table} table @param {import("./types.js").Document} document @param {import("./types.js").Index[]} [indexes] */
+export declare function removeIndexes(tx: import("@slatedb/uniffi").DbTransaction, table: import("./types.js").Table, document: import("./types.js").Document, indexes?: import("./types.js").Index[]): Promise<void>;
+/** @param {import("@slatedb/uniffi").DbTransaction} tx @param {import("./types.js").Table} table @param {import("./types.js").Document} document @param {import("./types.js").Index[]} [indexes] */
+export declare function addIndexes(tx: import("@slatedb/uniffi").DbTransaction, table: import("./types.js").Table, document: import("./types.js").Document, indexes?: import("./types.js").Index[]): Promise<void>;

package/types/query.d.ts

@@ -0,0 +1,49 @@
+export declare class Query {
+    collection: import("./collection.js").Collection;
+    ast: import("./types.js").WhereNode | null;
+    order: import("./types.js").IndexField[];
+    select: string[] | undefined;
+    limit: number | undefined;
+    cursor: string | undefined;
+    fingerprint: string;
+    plan: {
+        prefix: Buffer<ArrayBuffer>;
+        index: null;
+        key?: undefined;
+    } | {
+        prefix: Buffer<ArrayBuffer>;
+        index: import("./types.js").Index;
+        key?: undefined;
+    } | {
+        prefix?: undefined;
+        key: Buffer<ArrayBuffer>;
+        index: null;
+    };
+    sessionId: string | null;
+    /** @param {import("./collection.js").Collection} collection @param {import("./types.js").QueryOptions} options */
+    constructor(collection: import("./collection.js").Collection, options: import("./types.js").QueryOptions);
+    _plan(): {
+        prefix: Buffer<ArrayBuffer>;
+        index: null;
+        key?: undefined;
+    } | {
+        prefix: Buffer<ArrayBuffer>;
+        index: import("./types.js").Index;
+        key?: undefined;
+    } | {
+        prefix?: undefined;
+        key: Buffer<ArrayBuffer>;
+        index: null;
+    };
+    /** @param {import("./types.js").Reader} reader @param {Uint8Array} [after] */
+    _rows(reader: import("./types.js").Reader, after?: Uint8Array): AsyncGenerator<{
+        key: Buffer<ArrayBuffer>;
+        value: import("./types.js").Document;
+    }, void, unknown>;
+    page(): Promise<{
+        items: import("./types.js").Document[];
+        nextCursor: string | null;
+    }>;
+    [Symbol.asyncIterator](): AsyncGenerator<import("./types.js").Document, void, unknown>;
+    close(): void;
+}

package/types/schema.d.ts

@@ -0,0 +1,8 @@
+/** @param {{ version: number }} config @param {import("./types.js").TableDefinition[]} definitions @returns {import("./types.js").CompiledSchema} */
+export declare function compileSchema(config: {
+    version: number;
+}, definitions: import("./types.js").TableDefinition[]): import("./types.js").CompiledSchema;
+/** @param {import("./types.js").Table} table @param {unknown} document @param {boolean} [applyDefaults] @returns {import("./types.js").Document} */
+export declare function validateDocument(table: import("./types.js").Table, document: unknown, applyDefaults?: boolean): import("./types.js").Document;
+/** @param {import("./types.js").StoredSchema} previous @param {import("./types.js").StoredSchema} next @returns {import("./types.js").SchemaDiff} */
+export declare function schemaDiff(previous: import("./types.js").StoredSchema, next: import("./types.js").StoredSchema): import("./types.js").SchemaDiff;

package/types/storage.d.ts

@@ -0,0 +1,58 @@
+import { ObjectStore } from "@slatedb/uniffi";
+import { Collection } from "./collection.js";
+/** @param {import("./types.js").Reader} reader @param {Uint8Array} prefix @param {Uint8Array} [after] */
+export declare function scan(reader: import("./types.js").Reader, prefix: Uint8Array, after?: Uint8Array): AsyncGenerator<{
+    key: Buffer<ArrayBuffer>;
+    value: Buffer<ArrayBuffer>;
+}, void, unknown>;
+export declare class Database {
+    config: import("./types.js").DatabaseConfig;
+    cursorTtlMs: number;
+    definition: import("./types.js").CompiledSchema | null;
+    native: import("@slatedb/uniffi").Db | null;
+    store: ObjectStore | null;
+    opening: Promise<void> | null;
+    closed: boolean;
+    /** @type {Map<string, import("./types.js").Session>} */
+    sessions: Map<string, import("./types.js").Session>;
+    /** @param {import("./types.js").DatabaseConfig} config */
+    constructor(config: import("./types.js").DatabaseConfig);
+    /** @param {{ version: number }} config @param {import("./types.js").TableDefinition[]} definitions */
+    schema(config: {
+        version: number;
+    }, definitions: import("./types.js").TableDefinition[]): this;
+    _ready(): Promise<void>;
+    _open(): Promise<void>;
+    /** @param {import("./types.js").SchemaDiff} diff */
+    _migrate(diff: import("./types.js").SchemaDiff): Promise<void>;
+    /** @param {string} name */
+    collection(name: string): Promise<Collection>;
+    /** @template T @param {(tx: import("@slatedb/uniffi").DbTransaction) => Promise<T>} fn @returns {Promise<T>} */
+    _atomic<T>(fn: (tx: import("@slatedb/uniffi").DbTransaction) => Promise<T>): Promise<T>;
+    /** @template T @param {(tx: { collection: (name: string) => Promise<Collection> }) => Promise<T>} callback @returns {Promise<T>} */
+    transaction<T>(callback: (tx: {
+        collection: (name: string) => Promise<Collection>;
+    }) => Promise<T>): Promise<T>;
+    _session(): void;
+    /** @param {string} fingerprint */
+    _newSession(fingerprint: string): Promise<{
+        id: `${string}-${string}-${string}-${string}-${string}`;
+        session: {
+            snapshot: import("@slatedb/uniffi").DbSnapshot;
+            fingerprint: string;
+            lastUsed: number;
+            active: number;
+        };
+    }>;
+    /** @param {string} id @param {import("./types.js").Session} session */
+    _armSession(id: string, session: import("./types.js").Session): void;
+    /** @param {import("./types.js").Session} session */
+    _holdSession(session: import("./types.js").Session): void;
+    /** @param {string} id */
+    _idleSession(id: string): void;
+    /** @param {string} id @param {string} fingerprint */
+    _getSession(id: string, fingerprint: string): import("./types.js").Session;
+    /** @param {string} id */
+    _releaseSession(id: string): void;
+    close(): Promise<void>;
+}

package/types/types.d.ts

@@ -0,0 +1,160 @@
+export type Direction = "asc" | "desc";
+export type Document = Record<string, unknown> & {
+    id: string | number;
+};
+export type DatabaseConfig = {
+    store: string;
+    path: string;
+    cursorTtlMs?: number;
+};
+export type ArkTypeDefinition = string | import("arktype").Type<unknown> | readonly ArkTypeValue[] | {
+    [key: string]: ArkTypeValue;
+};
+export type ArkTypeValue = ArkTypeDefinition | null | boolean | number | bigint | Date | Uint8Array;
+export type DataValue = null | boolean | number | string | bigint | Date | Uint8Array | readonly DataValue[] | {
+    [key: string]: DataValue;
+};
+export type ColumnDefinition = {
+    type: ArkTypeDefinition;
+    primary?: boolean;
+    default?: DataValue | (() => DataValue);
+};
+export type IndexDefinition = {
+    name: string;
+    method?: "btree";
+    columns: (string | {
+        field: string;
+        direction?: Direction;
+    })[];
+    unique?: boolean;
+};
+export type TableDefinition = {
+    table: string;
+    columns: Record<string, ColumnDefinition>;
+    indexes?: IndexDefinition[];
+};
+export type IndexField = {
+    name: string;
+    direction: Direction;
+};
+export type Index = {
+    name: string;
+    method: "btree";
+    fields: IndexField[];
+    unique: boolean;
+};
+export type Table = {
+    name: string;
+    columns: Record<string, ColumnDefinition>;
+    indexes: Index[];
+    validator: (document: unknown) => unknown;
+};
+export type StoredColumn = {
+    type: string;
+    primary: boolean;
+    optional: boolean;
+    default: null | {
+        kind: string;
+        value?: string;
+    };
+};
+export type StoredTable = {
+    columns: Record<string, StoredColumn>;
+    indexes: Index[];
+};
+export type StoredSchema = {
+    version: number;
+    tables: Record<string, StoredTable>;
+};
+export type CompiledSchema = {
+    version: number;
+    tables: Map<string, Table>;
+    stored: StoredSchema;
+};
+export type SchemaDiff = {
+    changed: boolean;
+    additions: Map<string, {
+        columns: string[];
+        indexes: Index[];
+    }>;
+};
+export type Reader = import("@slatedb/uniffi").Db | import("@slatedb/uniffi").DbSnapshot | import("@slatedb/uniffi").DbTransaction;
+export type Session = {
+    snapshot: import("@slatedb/uniffi").DbSnapshot;
+    fingerprint: string;
+    lastUsed: number;
+    active: number;
+    timer?: NodeJS.Timeout;
+};
+export type Predicate = {
+    op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "contains" | "startsWith" | "exists";
+    path: string;
+    value: unknown;
+};
+export type WhereNode = {
+    op: "and";
+    conditions: WhereNode[];
+} | {
+    op: "or";
+    conditions: WhereNode[];
+} | {
+    op: "not";
+    condition: WhereNode;
+} | Predicate;
+export type WhereBuilder = {
+    eq: (path: string, value: unknown) => WhereNode;
+    ne: (path: string, value: unknown) => WhereNode;
+    gt: (path: string, value: unknown) => WhereNode;
+    gte: (path: string, value: unknown) => WhereNode;
+    lt: (path: string, value: unknown) => WhereNode;
+    lte: (path: string, value: unknown) => WhereNode;
+    in: (path: string, value: unknown[]) => WhereNode;
+    contains: (path: string, value: unknown) => WhereNode;
+    startsWith: (path: string, value: string) => WhereNode;
+    exists: (path: string, value?: boolean) => WhereNode;
+    and: (...conditions: WhereNode[]) => WhereNode;
+    or: (...conditions: WhereNode[]) => WhereNode;
+    not: (condition: WhereNode) => WhereNode;
+};
+export type OrderBuilder = {
+    asc: (path: string) => OrderBuilder;
+    desc: (path: string) => OrderBuilder;
+};
+export type QueryOptions = {
+    where?: (builder: WhereBuilder) => WhereNode;
+    orderBy?: (builder: OrderBuilder) => unknown;
+    select?: string[];
+    limit?: number;
+    cursor?: string;
+};
+export type Cursor = {
+    id: string;
+    last: Buffer;
+    fingerprint: string;
+};
+/** @typedef {"asc" | "desc"} Direction */
+/** @typedef {Record<string, unknown> & { id: string | number }} Document */
+/** @typedef {{ store: string, path: string, cursorTtlMs?: number }} DatabaseConfig */
+/** @typedef {string | import("arktype").Type<unknown> | readonly ArkTypeValue[] | { [key: string]: ArkTypeValue }} ArkTypeDefinition */
+/** @typedef {ArkTypeDefinition | null | boolean | number | bigint | Date | Uint8Array} ArkTypeValue */
+/** @typedef {null | boolean | number | string | bigint | Date | Uint8Array | readonly DataValue[] | { [key: string]: DataValue }} DataValue */
+/** @typedef {{ type: ArkTypeDefinition, primary?: boolean, default?: DataValue | (() => DataValue) }} ColumnDefinition */
+/** @typedef {{ name: string, method?: "btree", columns: (string | { field: string, direction?: Direction })[], unique?: boolean }} IndexDefinition */
+/** @typedef {{ table: string, columns: Record<string, ColumnDefinition>, indexes?: IndexDefinition[] }} TableDefinition */
+/** @typedef {{ name: string, direction: Direction }} IndexField */
+/** @typedef {{ name: string, method: "btree", fields: IndexField[], unique: boolean }} Index */
+/** @typedef {{ name: string, columns: Record<string, ColumnDefinition>, indexes: Index[], validator: (document: unknown) => unknown }} Table */
+/** @typedef {{ type: string, primary: boolean, optional: boolean, default: null | { kind: string, value?: string } }} StoredColumn */
+/** @typedef {{ columns: Record<string, StoredColumn>, indexes: Index[] }} StoredTable */
+/** @typedef {{ version: number, tables: Record<string, StoredTable> }} StoredSchema */
+/** @typedef {{ version: number, tables: Map<string, Table>, stored: StoredSchema }} CompiledSchema */
+/** @typedef {{ changed: boolean, additions: Map<string, { columns: string[], indexes: Index[] }> }} SchemaDiff */
+/** @typedef {import("@slatedb/uniffi").Db | import("@slatedb/uniffi").DbSnapshot | import("@slatedb/uniffi").DbTransaction} Reader */
+/** @typedef {{ snapshot: import("@slatedb/uniffi").DbSnapshot, fingerprint: string, lastUsed: number, active: number, timer?: NodeJS.Timeout }} Session */
+/** @typedef {{ op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "contains" | "startsWith" | "exists", path: string, value: unknown }} Predicate */
+/** @typedef {{ op: "and", conditions: WhereNode[] } | { op: "or", conditions: WhereNode[] } | { op: "not", condition: WhereNode } | Predicate} WhereNode */
+/** @typedef {{ eq: (path: string, value: unknown) => WhereNode, ne: (path: string, value: unknown) => WhereNode, gt: (path: string, value: unknown) => WhereNode, gte: (path: string, value: unknown) => WhereNode, lt: (path: string, value: unknown) => WhereNode, lte: (path: string, value: unknown) => WhereNode, in: (path: string, value: unknown[]) => WhereNode, contains: (path: string, value: unknown) => WhereNode, startsWith: (path: string, value: string) => WhereNode, exists: (path: string, value?: boolean) => WhereNode, and: (...conditions: WhereNode[]) => WhereNode, or: (...conditions: WhereNode[]) => WhereNode, not: (condition: WhereNode) => WhereNode }} WhereBuilder */
+/** @typedef {{ asc: (path: string) => OrderBuilder, desc: (path: string) => OrderBuilder }} OrderBuilder */
+/** @typedef {{ where?: (builder: WhereBuilder) => WhereNode, orderBy?: (builder: OrderBuilder) => unknown, select?: string[], limit?: number, cursor?: string }} QueryOptions */
+/** @typedef {{ id: string, last: Buffer, fingerprint: string }} Cursor */
+export {};