muya 2.1.1 → 2.1.2

package/types/sqlite/table/backend.d.ts

@@ -0,0 +1,20 @@
+export declare const IN_MEMORY_DB = ":memory:";
+export interface QueryResult {
+    /** The number of rows affected by the query. */
+    rowsAffected: number;
+    /**
+     * The last inserted `id`.
+     *
+     * This value is not set for Postgres databases. If the
+     * last inserted id is required on Postgres, the `select` function
+     * must be used, with a `RETURNING` clause
+     * (`INSERT INTO todos (title) VALUES ($1) RETURNING id`).
+     */
+    lastInsertId?: number;
+}
+export interface Backend {
+    execute: (query: string, bindValues?: unknown[]) => Promise<QueryResult>;
+    select: <T>(query: string, bindValues?: unknown[]) => Promise<T>;
+    transaction: (callback: (tx: Backend) => Promise<void>) => Promise<void>;
+    path: string;
+}

package/types/sqlite/table/bun-backend.d.ts

@@ -0,0 +1,2 @@
+import type { Backend } from './backend';
+export declare function bunMemoryBackend(): Backend;

package/types/sqlite/table/map-deque.d.ts

@@ -0,0 +1,5 @@
+export declare class MapDeque<K, V> extends Map<K, V> {
+    private maxSize;
+    constructor(maxSize: number, entries?: ReadonlyArray<readonly [K, V]> | null);
+    set(key: K, value: V): this;
+}

package/types/sqlite/table/table.d.ts

@@ -0,0 +1,3 @@
+import type { Table, DbOptions, DocType } from './table.types';
+export declare const DEFAULT_STEP_SIZE = 100;
+export declare function createTable<Document extends DocType>(options: DbOptions<Document>): Promise<Table<Document>>;

package/types/sqlite/table/table.types.d.ts

@@ -0,0 +1,52 @@
+import type { Backend } from './backend';
+import type { Where } from './where';
+export type DocType = {
+    [key: string]: any;
+};
+export type KeyTypeAvailable = 'string' | 'number';
+export interface DbOptions<Document extends DocType> {
+    readonly sorBy?: keyof Document;
+    readonly order?: 'asc' | 'desc';
+    readonly tableName: string;
+    readonly indexes?: Array<keyof Document>;
+    readonly backend: Backend;
+    /**
+     * Optional key. If omitted, the table uses implicit SQLite ROWID as the key.
+     */
+    readonly key?: keyof Document;
+}
+interface DbNotGeneric {
+    readonly backend: Backend;
+}
+export interface SearchOptions<Document extends DocType, Selected = Document> {
+    readonly sorBy?: keyof Document;
+    readonly order?: 'asc' | 'desc';
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly where?: Where<Document>;
+    readonly stepSize?: number;
+    /**
+     * Naive projection. Prefer specialized queries for heavy fan-out graphs.
+     */
+    readonly select?: (document: Document, meta: {
+        rowId: number;
+    }) => Selected;
+}
+export type Key = string | number;
+export type MutationOp = 'insert' | 'update' | 'delete';
+export interface MutationResult {
+    key: Key;
+    op: MutationOp;
+}
+export interface Table<Document extends DocType> extends DbNotGeneric {
+    readonly set: (document: Document, backendOverride?: Backend) => Promise<MutationResult>;
+    readonly batchSet: (documents: Document[]) => Promise<MutationResult[]>;
+    readonly get: <Selected = Document>(key: Key, selector?: (document: Document) => Selected) => Promise<Selected | undefined>;
+    readonly delete: (key: Key) => Promise<MutationResult | undefined>;
+    readonly search: <Selected = Document>(options?: SearchOptions<Document, Selected>) => AsyncIterableIterator<Selected>;
+    readonly count: (options?: {
+        where?: Where<Document>;
+    }) => Promise<number>;
+    readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
+}
+export {};

package/types/sqlite/table/where.d.ts

@@ -0,0 +1,32 @@
+export interface Field {
+    readonly table: string;
+    readonly field: string;
+}
+interface Condition<Document extends Record<string, unknown>, K extends keyof Document = keyof Document> {
+    readonly is?: Document[K] | Array<Document[K]>;
+    readonly isNot?: Document[K] | Array<Document[K]>;
+    readonly gt?: Document[K] | Array<Document[K]>;
+    readonly gte?: Document[K] | Array<Document[K]>;
+    readonly lt?: Document[K] | Array<Document[K]>;
+    readonly lte?: Document[K] | Array<Document[K]>;
+    readonly in?: Document[K] | Array<Document[K]>;
+    readonly notIn?: Document[K] | Array<Document[K]>;
+    readonly like?: Document[K] | Array<Document[K]>;
+}
+/**
+ * We extend `keyof Document` by the special literal "KEY".
+ * That means users can write `{ KEY: ... }` in addition to `{ someField: ... }`.
+ *
+ * - If K extends keyof Document, then primitive values must match Document[K].
+ * - If K === "KEY", then primitive values are treated as strings/Array<string>.
+ */
+export type Where<Document extends Record<string, unknown>> = {
+    [K in keyof Document | 'KEY']?: Condition<Document, K extends keyof Document ? K : keyof Document> | (K extends keyof Document ? Document[K] : string) | (K extends keyof Document ? Array<Document[K]> : string[]);
+} | {
+    readonly AND?: Array<Where<Document>>;
+    readonly OR?: Array<Where<Document>>;
+    readonly NOT?: Where<Document>;
+};
+export declare function getWhere<Document extends Record<string, unknown>>(where: Where<Document>, tableAlias?: string): string;
+export declare function getWhereQuery<Document extends Record<string, unknown>>(where: Where<Document>): string;
+export {};

package/types/sqlite/use-sqlite-value.d.ts

@@ -0,0 +1,21 @@
+import { type DependencyList } from 'react';
+import type { SyncTable } from './create-sqlite-state';
+import type { DocType } from './table/table.types';
+import type { Where } from './table/where';
+export interface SqLiteActions {
+    readonly next: () => Promise<boolean>;
+    readonly reset: () => Promise<void>;
+}
+export interface UseSearchOptions<Document extends DocType, Selected = Document> {
+    readonly sorBy?: keyof Document;
+    readonly order?: 'asc' | 'desc';
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly where?: Where<Document>;
+    readonly stepSize?: number;
+    /**
+     * Naive projection. Prefer specialized queries for heavy fan-out graphs.
+     */
+    readonly select?: (document: Document) => Selected;
+}
+export declare function useSqliteValue<Document extends DocType, Selected = Document>(state: SyncTable<Document>, options?: UseSearchOptions<Document, Selected>, deps?: DependencyList): [undefined extends Selected ? Document[] : Selected[], SqLiteActions];

package/types/types.d.ts

@@ -59,4 +59,5 @@ export interface State<T> extends GetState<T> {
      */
     withName: (name: string) => State<T>;
     isSet: true;
+    cache: Cache<T>;
 }

package/types/utils/common.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, IsEqual } from '../types';
+import type { Cache, IsEqual, State } from '../types';
 export interface CancelablePromise<T> {
     promise: Promise<T>;
     controller?: AbortController;
@@ -17,4 +17,4 @@ export declare function canUpdate<T>(cache: Cache<T>, isEqual?: IsEqual<T>): boo
 /**
  * Handle async updates for `create` and `select`
  */
-export declare function handleAsyncUpdate<T>(cache: Cache<T>, emit: () => void, value: T): T;
+export declare function handleAsyncUpdate<T>(state: State<T>, value: T): T;