tablinum 0.0.1 → 0.1.1

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema/collection.d.ts

@@ -0,0 +1,12 @@
+import type { FieldDef } from "./field.ts";
+export type CollectionFields = Record<string, FieldDef<unknown>>;
+export interface CollectionDef<out F extends CollectionFields = CollectionFields> {
+    readonly _tag: "CollectionDef";
+    readonly name: string;
+    readonly fields: F;
+    readonly indices: ReadonlyArray<string>;
+}
+export interface CollectionOptions<F extends CollectionFields> {
+    readonly indices?: ReadonlyArray<string & keyof F>;
+}
+export declare function collection<F extends CollectionFields>(name: string, fields: F, options?: CollectionOptions<F>): CollectionDef<F>;

package/dist/schema/field.d.ts

@@ -0,0 +1,17 @@
+export type FieldKind = "string" | "number" | "boolean" | "json";
+export interface FieldDef<out T = unknown> {
+    readonly _tag: "FieldDef";
+    readonly kind: FieldKind;
+    readonly isOptional: boolean;
+    readonly isArray: boolean;
+    /** Phantom type carrier — never read at runtime. */
+    readonly _T?: T;
+}
+export declare const field: {
+    string: () => FieldDef<string>;
+    number: () => FieldDef<number>;
+    boolean: () => FieldDef<boolean>;
+    json: () => FieldDef<unknown>;
+    optional: <T>(inner: FieldDef<T>) => FieldDef<T | undefined>;
+    array: <T>(inner: FieldDef<T>) => FieldDef<ReadonlyArray<T>>;
+};

package/{src/schema/types.ts → dist/schema/types.d.ts}

@@ -1,19 +1,14 @@
 import type { CollectionDef, CollectionFields } from "./collection.ts";
 import type { FieldDef } from "./field.ts";
-
 /** Extract the TypeScript type from a FieldDef phantom. */
 export type InferFieldType<F> = F extends FieldDef<infer T> ? T : never;
-
 /** Infer the full record type from a CollectionDef, including the auto-injected `id`. */
-export type InferRecord<C> =
-  C extends CollectionDef<infer F>
-    ? { readonly id: string } & {
-        readonly [K in keyof F]: InferFieldType<F[K]>;
-      }
-    : never;
-
+export type InferRecord<C> = C extends CollectionDef<infer F> ? {
+    readonly id: string;
+} & {
+    readonly [K in keyof F]: InferFieldType<F[K]>;
+} : never;
 /** A schema configuration mapping collection names to their definitions. */
 export type SchemaConfig = Record<string, CollectionDef<CollectionFields>>;
-
 /** Extract indexed field names from a CollectionDef. */
 export type IndexedFields<C> = C extends CollectionDef<infer _F> ? C["indices"][number] : never;

package/dist/schema/validate.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import type { CollectionDef, CollectionFields } from "./collection.ts";
+import { ValidationError } from "../errors.ts";
+export type RecordValidator<F extends CollectionFields> = (input: unknown) => Effect.Effect<{
+    readonly id: string;
+} & {
+    readonly [K in keyof F]: unknown;
+}, ValidationError>;
+export declare function buildValidator<F extends CollectionFields>(collectionName: string, def: CollectionDef<F>): RecordValidator<F>;
+export type PartialValidator<F extends CollectionFields> = (input: unknown) => Effect.Effect<{
+    readonly [K in keyof F]?: unknown;
+}, ValidationError>;
+export declare function buildPartialValidator<F extends CollectionFields>(collectionName: string, def: CollectionDef<F>): PartialValidator<F>;

package/dist/storage/events-store.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import type { IDBStorageHandle, StoredEvent } from "./idb.ts";
+import type { StorageError } from "../errors.ts";
+export declare function putEvent(storage: IDBStorageHandle, event: StoredEvent): Effect.Effect<void, StorageError>;
+export declare function getEventsByRecord(storage: IDBStorageHandle, collection: string, recordId: string): Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;
+export declare function getAllEvents(storage: IDBStorageHandle): Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;

package/dist/storage/giftwraps-store.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import type { IDBStorageHandle, StoredGiftWrap } from "./idb.ts";
+import type { StorageError } from "../errors.ts";
+export declare function putGiftWrap(storage: IDBStorageHandle, gw: StoredGiftWrap): Effect.Effect<void, StorageError>;
+export declare function getGiftWrap(storage: IDBStorageHandle, id: string): Effect.Effect<StoredGiftWrap | undefined, StorageError>;
+export declare function getAllGiftWraps(storage: IDBStorageHandle): Effect.Effect<ReadonlyArray<StoredGiftWrap>, StorageError>;

package/dist/storage/idb.d.ts

@@ -0,0 +1,35 @@
+import { Effect, Scope } from "effect";
+import { StorageError } from "../errors.ts";
+import type { SchemaConfig } from "../schema/types.ts";
+export interface StoredEvent {
+    readonly id: string;
+    readonly collection: string;
+    readonly recordId: string;
+    readonly kind: "create" | "update" | "delete";
+    readonly data: Record<string, unknown> | null;
+    readonly createdAt: number;
+}
+export interface StoredGiftWrap {
+    readonly id: string;
+    readonly event: Record<string, unknown>;
+    readonly createdAt: number;
+}
+export interface IDBStorageHandle {
+    readonly putRecord: (collection: string, record: Record<string, unknown>) => Effect.Effect<void, StorageError>;
+    readonly getRecord: (collection: string, id: string) => Effect.Effect<Record<string, unknown> | undefined, StorageError>;
+    readonly getAllRecords: (collection: string) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
+    readonly countRecords: (collection: string) => Effect.Effect<number, StorageError>;
+    readonly clearRecords: (collection: string) => Effect.Effect<void, StorageError>;
+    readonly getByIndex: (collection: string, indexName: string, value: IDBValidKey) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
+    readonly getByIndexRange: (collection: string, indexName: string, range: IDBKeyRange) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
+    readonly getAllSorted: (collection: string, indexName: string, direction?: "next" | "prev") => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
+    readonly putEvent: (event: StoredEvent) => Effect.Effect<void, StorageError>;
+    readonly getEvent: (id: string) => Effect.Effect<StoredEvent | undefined, StorageError>;
+    readonly getAllEvents: () => Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;
+    readonly getEventsByRecord: (collection: string, recordId: string) => Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;
+    readonly putGiftWrap: (gw: StoredGiftWrap) => Effect.Effect<void, StorageError>;
+    readonly getGiftWrap: (id: string) => Effect.Effect<StoredGiftWrap | undefined, StorageError>;
+    readonly getAllGiftWraps: () => Effect.Effect<ReadonlyArray<StoredGiftWrap>, StorageError>;
+    readonly close: () => Effect.Effect<void>;
+}
+export declare function openIDBStorage(dbName: string | undefined, schema: SchemaConfig): Effect.Effect<IDBStorageHandle, StorageError, Scope.Scope>;

package/dist/storage/lww.d.ts

@@ -0,0 +1,10 @@
+export interface EventMeta {
+    readonly id: string;
+    readonly createdAt: number;
+}
+/**
+ * Last-write-wins resolution.
+ * Higher `createdAt` wins. Ties broken by lowest event ID (lexicographic).
+ * Returns the winner.
+ */
+export declare function resolveWinner<T extends EventMeta>(existing: T | null, incoming: T): T;

package/dist/storage/records-store.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import type { IDBStorageHandle, StoredEvent } from "./idb.ts";
+import type { StorageError } from "../errors.ts";
+/**
+ * Apply an event to the records store using LWW resolution.
+ * Returns true if the incoming event won and the record was updated.
+ */
+export declare function applyEvent(storage: IDBStorageHandle, event: StoredEvent): Effect.Effect<boolean, StorageError>;
+/**
+ * Rebuild the records store by clearing it and replaying all events.
+ */
+export declare function rebuild(storage: IDBStorageHandle, collections: ReadonlyArray<string>): Effect.Effect<void, StorageError>;

package/dist/svelte/collection.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
+import type { InferRecord } from "../schema/types.ts";
+import type { CollectionHandle } from "../crud/collection-handle.ts";
+import { type SvelteWhereClause, type SvelteOrderByBuilder } from "./query.svelte.ts";
+export declare class Collection<C extends CollectionDef<CollectionFields>> {
+    #private;
+    items: any;
+    error: any;
+    constructor(handle: CollectionHandle<C>);
+    add: (data: Omit<InferRecord<C>, "id">) => Promise<string>;
+    update: (id: string, data: Partial<Omit<InferRecord<C>, "id">>) => Promise<void>;
+    delete: (id: string) => Promise<void>;
+    get: (id: string) => Promise<InferRecord<C>>;
+    first: () => Promise<InferRecord<C> | null>;
+    count: () => Promise<number>;
+    where: (field: string & keyof Omit<InferRecord<C>, "id">) => SvelteWhereClause<InferRecord<C>>;
+    orderBy: (field: string & keyof Omit<InferRecord<C>, "id">) => SvelteOrderByBuilder<InferRecord<C>>;
+    /** @internal Called by Database.close() */
+    _destroy(): void;
+}

package/dist/svelte/database.svelte.d.ts

@@ -0,0 +1,15 @@
+import { Scope } from "effect";
+import type { SchemaConfig } from "../schema/types.ts";
+import type { DatabaseHandle } from "../db/database-handle.ts";
+import { Collection } from "./collection.svelte.ts";
+export declare class Database<S extends SchemaConfig> {
+    #private;
+    status: any;
+    error: any;
+    constructor(handle: DatabaseHandle<S>, scope: Scope.Closeable);
+    collection<K extends string & keyof S>(name: K): Collection<S[K]>;
+    exportKey(): string;
+    close: () => Promise<void>;
+    sync: () => Promise<void>;
+    rebuild: () => Promise<void>;
+}

package/dist/svelte/index.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { SchemaConfig } from "../schema/types.ts";
+import { type TablinumConfig } from "../db/create-tablinum.ts";
+import { Database } from "./database.svelte.ts";
+export { field } from "../schema/field.ts";
+export { collection } from "../schema/collection.ts";
+export type { CollectionDef, CollectionFields } from "../schema/collection.ts";
+export type { FieldDef, FieldKind } from "../schema/field.ts";
+export type { InferRecord, SchemaConfig } from "../schema/types.ts";
+export type { TablinumConfig } from "../db/create-tablinum.ts";
+export type { SyncStatus } from "../db/database-handle.ts";
+export { ValidationError, StorageError, CryptoError, RelayError, SyncError, NotFoundError, ClosedError, } from "../errors.ts";
+export { Database } from "./database.svelte.ts";
+export { Collection } from "./collection.svelte.ts";
+export { LiveQuery } from "./live-query.svelte.ts";
+export type { SvelteQueryBuilder, SvelteWhereClause, SvelteOrderByBuilder, } from "./query.svelte.ts";
+export declare function createTablinum<S extends SchemaConfig>(config: TablinumConfig<S>): Promise<Database<S>>;