tablinum 0.0.1 → 0.1.1

package/src/crud/collection-handle.ts

@@ -1,189 +0,0 @@
-import { Effect, Stream } from "effect";
-import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
-import type { InferRecord } from "../schema/types.ts";
-import type { RecordValidator, PartialValidator } from "../schema/validate.ts";
-import type { IDBStorageHandle, StoredEvent } from "../storage/idb.ts";
-import { applyEvent } from "../storage/records-store.ts";
-import { NotFoundError, StorageError, ValidationError } from "../errors.ts";
-import { uuidv7 } from "../utils/uuid.ts";
-import type { WatchContext } from "./watch.ts";
-import { notifyChange, watchCollection } from "./watch.ts";
-import type { WhereClause, OrderByBuilder } from "./query-builder.ts";
-import { createWhereClause, createOrderByBuilder } from "./query-builder.ts";
-
-export interface CollectionHandle<C extends CollectionDef<CollectionFields>> {
-  readonly add: (
-    data: Omit<InferRecord<C>, "id">,
-  ) => Effect.Effect<string, ValidationError | StorageError>;
-  readonly update: (
-    id: string,
-    data: Partial<Omit<InferRecord<C>, "id">>,
-  ) => Effect.Effect<void, ValidationError | StorageError | NotFoundError>;
-  readonly delete: (id: string) => Effect.Effect<void, StorageError | NotFoundError>;
-  readonly get: (id: string) => Effect.Effect<InferRecord<C>, StorageError | NotFoundError>;
-  readonly first: () => Effect.Effect<InferRecord<C> | null, StorageError>;
-  readonly count: () => Effect.Effect<number, StorageError>;
-  readonly watch: () => Stream.Stream<ReadonlyArray<InferRecord<C>>, StorageError>;
-  readonly where: (field: string & keyof Omit<InferRecord<C>, "id">) => WhereClause<InferRecord<C>>;
-  readonly orderBy: (
-    field: string & keyof Omit<InferRecord<C>, "id">,
-  ) => OrderByBuilder<InferRecord<C>>;
-}
-
-function mapRecord<C extends CollectionDef<CollectionFields>>(
-  record: Record<string, unknown>,
-): InferRecord<C> {
-  const { _deleted, _updatedAt, ...fields } = record;
-  return fields as InferRecord<C>;
-}
-
-export type OnWriteCallback = (event: StoredEvent) => Effect.Effect<void>;
-
-export function createCollectionHandle<C extends CollectionDef<CollectionFields>>(
-  def: C,
-  storage: IDBStorageHandle,
-  watchCtx: WatchContext,
-  validator: RecordValidator<C["fields"]>,
-  partialValidator: PartialValidator<C["fields"]>,
-  makeEventId: () => string,
-  onWrite?: OnWriteCallback,
-): CollectionHandle<C> {
-  const collectionName = def.name;
-
-  const handle: CollectionHandle<C> = {
-    add: (data) =>
-      Effect.gen(function* () {
-        const id = uuidv7();
-        const fullRecord = { id, ...data };
-        yield* validator(fullRecord);
-
-        const event: StoredEvent = {
-          id: makeEventId(),
-          collection: collectionName,
-          recordId: id,
-          kind: "create",
-          data: fullRecord as unknown as Record<string, unknown>,
-          createdAt: Date.now(),
-        };
-        yield* storage.putEvent(event);
-        yield* applyEvent(storage, event);
-        if (onWrite) yield* onWrite(event);
-        yield* notifyChange(watchCtx, {
-          collection: collectionName,
-          recordId: id,
-          kind: "create",
-        });
-        return id;
-      }),
-
-    update: (id, data) =>
-      Effect.gen(function* () {
-        const existing = yield* storage.getRecord(collectionName, id);
-        if (!existing || existing._deleted) {
-          return yield* new NotFoundError({
-            collection: collectionName,
-            id,
-          });
-        }
-        yield* partialValidator(data);
-        const { _deleted, _updatedAt, ...existingFields } = existing;
-        const merged = { ...existingFields, ...data, id };
-        yield* validator(merged);
-
-        const event: StoredEvent = {
-          id: makeEventId(),
-          collection: collectionName,
-          recordId: id,
-          kind: "update",
-          data: merged as Record<string, unknown>,
-          createdAt: Date.now(),
-        };
-        yield* storage.putEvent(event);
-        yield* applyEvent(storage, event);
-        if (onWrite) yield* onWrite(event);
-        yield* notifyChange(watchCtx, {
-          collection: collectionName,
-          recordId: id,
-          kind: "update",
-        });
-      }),
-
-    delete: (id) =>
-      Effect.gen(function* () {
-        const existing = yield* storage.getRecord(collectionName, id);
-        if (!existing || existing._deleted) {
-          return yield* new NotFoundError({
-            collection: collectionName,
-            id,
-          });
-        }
-
-        const event: StoredEvent = {
-          id: makeEventId(),
-          collection: collectionName,
-          recordId: id,
-          kind: "delete",
-          data: null,
-          createdAt: Date.now(),
-        };
-        yield* storage.putEvent(event);
-        yield* applyEvent(storage, event);
-        if (onWrite) yield* onWrite(event);
-        yield* notifyChange(watchCtx, {
-          collection: collectionName,
-          recordId: id,
-          kind: "delete",
-        });
-      }),
-
-    get: (id) =>
-      Effect.gen(function* () {
-        const record = yield* storage.getRecord(collectionName, id);
-        if (!record || record._deleted) {
-          return yield* new NotFoundError({
-            collection: collectionName,
-            id,
-          });
-        }
-        return mapRecord<C>(record);
-      }),
-
-    first: () =>
-      Effect.gen(function* () {
-        const all = yield* storage.getAllRecords(collectionName);
-        const found = all.find((r) => !r._deleted);
-        return found ? mapRecord<C>(found) : null;
-      }),
-
-    count: () =>
-      Effect.gen(function* () {
-        const all = yield* storage.getAllRecords(collectionName);
-        return all.filter((r) => !r._deleted).length;
-      }),
-
-    watch: () =>
-      watchCollection<InferRecord<C>>(watchCtx, storage, collectionName, undefined, mapRecord),
-
-    where: (fieldName) =>
-      createWhereClause<InferRecord<C>>(
-        storage,
-        watchCtx,
-        collectionName,
-        def,
-        fieldName,
-        mapRecord,
-      ),
-
-    orderBy: (fieldName) =>
-      createOrderByBuilder<InferRecord<C>>(
-        storage,
-        watchCtx,
-        collectionName,
-        def,
-        fieldName,
-        mapRecord,
-      ),
-  };
-
-  return handle;
-}

package/src/crud/query-builder.ts

@@ -1,414 +0,0 @@
-import { Effect, Ref, Stream } from "effect";
-import type { IDBStorageHandle } from "../storage/idb.ts";
-import type { StorageError, ValidationError } from "../errors.ts";
-import { ValidationError as VE } from "../errors.ts";
-import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
-import type { WatchContext } from "./watch.ts";
-
-// ---------------------------------------------------------------------------
-// Query plan (internal)
-// ---------------------------------------------------------------------------
-
-interface QueryPlan {
-  readonly fieldName?: string | undefined;
-  readonly filters: Array<(record: Record<string, unknown>) => boolean>;
-  readonly orderBy?: { field: string; direction: "asc" | "desc" } | undefined;
-  readonly offset?: number | undefined;
-  readonly limit?: number | undefined;
-  readonly indexQuery?:
-    | { field: string; range: IDBKeyRange | IDBValidKey; type: "value" | "range" }
-    | undefined;
-}
-
-function emptyPlan(): QueryPlan {
-  return { filters: [] };
-}
-
-// ---------------------------------------------------------------------------
-// Query context (shared deps for execution)
-// ---------------------------------------------------------------------------
-
-interface QueryContext {
-  readonly storage: IDBStorageHandle;
-  readonly watchCtx: WatchContext;
-  readonly collectionName: string;
-  readonly def: CollectionDef<CollectionFields>;
-  readonly mapRecord: (record: Record<string, unknown>) => unknown;
-}
-
-// ---------------------------------------------------------------------------
-// Execution
-// ---------------------------------------------------------------------------
-
-function executeQuery<T>(
-  ctx: QueryContext,
-  plan: QueryPlan,
-): Effect.Effect<ReadonlyArray<T>, StorageError | ValidationError> {
-  return Effect.gen(function* () {
-    // Validate field references
-    if (plan.fieldName) {
-      const fieldDef = ctx.def.fields[plan.fieldName];
-      if (!fieldDef) {
-        return yield* new VE({
-          message: `Unknown field "${plan.fieldName}" in collection "${ctx.collectionName}"`,
-          field: plan.fieldName,
-        });
-      }
-      if (fieldDef.kind === "json" || fieldDef.isArray) {
-        return yield* new VE({
-          message: `Field "${plan.fieldName}" does not support filtering (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`,
-          field: plan.fieldName,
-        });
-      }
-    }
-
-    // Fetch records — use index if available
-    let results: Record<string, unknown>[];
-    if (plan.indexQuery && ctx.def.indices.includes(plan.indexQuery.field)) {
-      if (plan.indexQuery.type === "value") {
-        results = [
-          ...(yield* ctx.storage.getByIndex(
-            ctx.collectionName,
-            plan.indexQuery.field,
-            plan.indexQuery.range as IDBValidKey,
-          )),
-        ];
-      } else {
-        results = [
-          ...(yield* ctx.storage.getByIndexRange(
-            ctx.collectionName,
-            plan.indexQuery.field,
-            plan.indexQuery.range as IDBKeyRange,
-          )),
-        ];
-      }
-    } else if (
-      plan.orderBy &&
-      ctx.def.indices.includes(plan.orderBy.field) &&
-      plan.filters.length === 0
-    ) {
-      // Use index for sorting when no filters need to be applied
-      results = [
-        ...(yield* ctx.storage.getAllSorted(
-          ctx.collectionName,
-          plan.orderBy.field,
-          plan.orderBy.direction === "desc" ? "prev" : "next",
-        )),
-      ];
-    } else {
-      results = [...(yield* ctx.storage.getAllRecords(ctx.collectionName))];
-    }
-
-    // Filter deleted records
-    results = results.filter((r) => !r._deleted);
-
-    // Apply filter predicates
-    for (const f of plan.filters) {
-      results = results.filter(f);
-    }
-
-    // Sort (if not already sorted by IDB)
-    if (plan.orderBy) {
-      const alreadySorted =
-        ctx.def.indices.includes(plan.orderBy.field) &&
-        plan.filters.length === 0 &&
-        !plan.indexQuery;
-      if (!alreadySorted) {
-        const { field, direction } = plan.orderBy;
-        results = results.sort((a, b) => {
-          const va = a[field] as string | number | boolean;
-          const vb = b[field] as string | number | boolean;
-          const cmp = va < vb ? -1 : va > vb ? 1 : 0;
-          return direction === "desc" ? -cmp : cmp;
-        });
-      }
-    }
-
-    // Offset
-    if (plan.offset) {
-      results = results.slice(plan.offset);
-    }
-
-    // Limit
-    if (plan.limit !== null && plan.limit !== undefined) {
-      results = results.slice(0, plan.limit);
-    }
-
-    // Map to user-facing type
-    return results.map(ctx.mapRecord) as ReadonlyArray<T>;
-  });
-}
-
-function watchQuery<T>(
-  ctx: QueryContext,
-  plan: QueryPlan,
-): Stream.Stream<ReadonlyArray<T>, StorageError | ValidationError> {
-  const query = () => executeQuery<T>(ctx, plan);
-
-  const changes = Stream.fromPubSub(ctx.watchCtx.pubsub).pipe(
-    Stream.filter((event) => event.collection === ctx.collectionName),
-    Stream.mapEffect(() =>
-      Effect.gen(function* () {
-        const replaying = yield* Ref.get(ctx.watchCtx.replayingRef);
-        if (replaying) return undefined;
-        return yield* query();
-      }),
-    ),
-    Stream.filter((result): result is ReadonlyArray<T> => result !== undefined),
-  );
-
-  return Stream.unwrap(
-    Effect.gen(function* () {
-      const initial = yield* query();
-      return Stream.concat(Stream.make(initial), changes);
-    }),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Public interfaces
-// ---------------------------------------------------------------------------
-
-export interface WhereClause<T> {
-  readonly equals: (value: string | number | boolean) => QueryBuilder<T>;
-  readonly above: (value: number) => QueryBuilder<T>;
-  readonly aboveOrEqual: (value: number) => QueryBuilder<T>;
-  readonly below: (value: number) => QueryBuilder<T>;
-  readonly belowOrEqual: (value: number) => QueryBuilder<T>;
-  readonly between: (
-    lower: number,
-    upper: number,
-    options?: { includeLower?: boolean; includeUpper?: boolean },
-  ) => QueryBuilder<T>;
-  readonly startsWith: (prefix: string) => QueryBuilder<T>;
-  readonly anyOf: (values: ReadonlyArray<string | number | boolean>) => QueryBuilder<T>;
-  readonly noneOf: (values: ReadonlyArray<string | number | boolean>) => QueryBuilder<T>;
-}
-
-export interface QueryBuilder<T> {
-  readonly and: (fn: (item: T) => boolean) => QueryBuilder<T>;
-  readonly sortBy: (field: string) => QueryBuilder<T>;
-  readonly reverse: () => QueryBuilder<T>;
-  readonly offset: (n: number) => QueryBuilder<T>;
-  readonly limit: (n: number) => QueryBuilder<T>;
-  readonly get: () => Effect.Effect<ReadonlyArray<T>, StorageError | ValidationError>;
-  readonly first: () => Effect.Effect<T | null, StorageError | ValidationError>;
-  readonly count: () => Effect.Effect<number, StorageError | ValidationError>;
-  readonly watch: () => Stream.Stream<ReadonlyArray<T>, StorageError | ValidationError>;
-}
-
-export interface OrderByBuilder<T> {
-  readonly reverse: () => OrderByBuilder<T>;
-  readonly offset: (n: number) => OrderByBuilder<T>;
-  readonly limit: (n: number) => OrderByBuilder<T>;
-  readonly get: () => Effect.Effect<ReadonlyArray<T>, StorageError | ValidationError>;
-  readonly first: () => Effect.Effect<T | null, StorageError | ValidationError>;
-  readonly count: () => Effect.Effect<number, StorageError | ValidationError>;
-  readonly watch: () => Stream.Stream<ReadonlyArray<T>, StorageError | ValidationError>;
-}
-
-// Keep for backwards compat
-export type QueryExecutor<T> = QueryBuilder<T>;
-
-// ---------------------------------------------------------------------------
-// Builders
-// ---------------------------------------------------------------------------
-
-function makeQueryBuilder<T>(ctx: QueryContext, plan: QueryPlan): QueryBuilder<T> {
-  return {
-    and: (fn) =>
-      makeQueryBuilder(ctx, {
-        ...plan,
-        filters: [...plan.filters, (r) => fn(ctx.mapRecord(r) as T)],
-      }),
-    sortBy: (field) =>
-      makeQueryBuilder(ctx, {
-        ...plan,
-        orderBy: { field, direction: plan.orderBy?.direction ?? "asc" },
-      }),
-    reverse: () =>
-      makeQueryBuilder(ctx, {
-        ...plan,
-        orderBy: {
-          field: plan.orderBy?.field ?? "id",
-          direction: plan.orderBy?.direction === "desc" ? "asc" : "desc",
-        },
-      }),
-    offset: (n) => makeQueryBuilder(ctx, { ...plan, offset: n }),
-    limit: (n) => makeQueryBuilder(ctx, { ...plan, limit: n }),
-    get: () => executeQuery<T>(ctx, plan),
-    first: () =>
-      Effect.gen(function* () {
-        const limitedPlan = { ...plan, limit: 1 };
-        const results = yield* executeQuery<T>(ctx, limitedPlan);
-        return results[0] ?? null;
-      }),
-    count: () =>
-      Effect.gen(function* () {
-        const results = yield* executeQuery<T>(ctx, plan);
-        return results.length;
-      }),
-    watch: () => watchQuery<T>(ctx, plan),
-  };
-}
-
-function makeOrderByBuilder<T>(ctx: QueryContext, plan: QueryPlan): OrderByBuilder<T> {
-  return {
-    reverse: () =>
-      makeOrderByBuilder(ctx, {
-        ...plan,
-        orderBy: {
-          field: plan.orderBy!.field,
-          direction: plan.orderBy!.direction === "desc" ? "asc" : "desc",
-        },
-      }),
-    offset: (n) => makeOrderByBuilder(ctx, { ...plan, offset: n }),
-    limit: (n) => makeOrderByBuilder(ctx, { ...plan, limit: n }),
-    get: () => executeQuery<T>(ctx, plan),
-    first: () =>
-      Effect.gen(function* () {
-        const limitedPlan = { ...plan, limit: 1 };
-        const results = yield* executeQuery<T>(ctx, limitedPlan);
-        return results[0] ?? null;
-      }),
-    count: () =>
-      Effect.gen(function* () {
-        const results = yield* executeQuery<T>(ctx, plan);
-        return results.length;
-      }),
-    watch: () => watchQuery<T>(ctx, plan),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Factory functions (called by CollectionHandle)
-// ---------------------------------------------------------------------------
-
-export function createWhereClause<T>(
-  storage: IDBStorageHandle,
-  watchCtx: WatchContext,
-  collectionName: string,
-  def: CollectionDef<CollectionFields>,
-  fieldName: string,
-  mapRecord: (record: Record<string, unknown>) => T,
-): WhereClause<T> {
-  const ctx: QueryContext = { storage, watchCtx, collectionName, def, mapRecord };
-  const fieldDef = def.fields[fieldName];
-  // IDB only supports string/number/Date/Array keys — not booleans
-  const isIndexed =
-    def.indices.includes(fieldName) &&
-    fieldDef !== null &&
-    fieldDef !== undefined &&
-    fieldDef.kind !== "boolean";
-
-  const withFilter = (
-    filterFn: (record: Record<string, unknown>) => boolean,
-    indexQuery?: QueryPlan["indexQuery"],
-  ): QueryBuilder<T> => {
-    const plan: QueryPlan = {
-      ...emptyPlan(),
-      fieldName,
-      filters: [filterFn],
-      indexQuery,
-    };
-    return makeQueryBuilder(ctx, plan);
-  };
-
-  return {
-    equals: (value) =>
-      withFilter(
-        (r) => r[fieldName] === value,
-        isIndexed ? { field: fieldName, range: value as IDBValidKey, type: "value" } : undefined,
-      ),
-
-    above: (value) =>
-      withFilter(
-        (r) => (r[fieldName] as number) > value,
-        isIndexed
-          ? { field: fieldName, range: IDBKeyRange.lowerBound(value, true), type: "range" }
-          : undefined,
-      ),
-
-    aboveOrEqual: (value) =>
-      withFilter(
-        (r) => (r[fieldName] as number) >= value,
-        isIndexed
-          ? { field: fieldName, range: IDBKeyRange.lowerBound(value, false), type: "range" }
-          : undefined,
-      ),
-
-    below: (value) =>
-      withFilter(
-        (r) => (r[fieldName] as number) < value,
-        isIndexed
-          ? { field: fieldName, range: IDBKeyRange.upperBound(value, true), type: "range" }
-          : undefined,
-      ),
-
-    belowOrEqual: (value) =>
-      withFilter(
-        (r) => (r[fieldName] as number) <= value,
-        isIndexed
-          ? { field: fieldName, range: IDBKeyRange.upperBound(value, false), type: "range" }
-          : undefined,
-      ),
-
-    between: (lower, upper, options) => {
-      const includeLower = options?.includeLower ?? true;
-      const includeUpper = options?.includeUpper ?? true;
-      return withFilter(
-        (r) => {
-          const v = r[fieldName] as number;
-          const aboveLower = includeLower ? v >= lower : v > lower;
-          const belowUpper = includeUpper ? v <= upper : v < upper;
-          return aboveLower && belowUpper;
-        },
-        isIndexed
-          ? {
-              field: fieldName,
-              range: IDBKeyRange.bound(lower, upper, !includeLower, !includeUpper),
-              type: "range",
-            }
-          : undefined,
-      );
-    },
-
-    startsWith: (prefix) =>
-      withFilter(
-        (r) => typeof r[fieldName] === "string" && (r[fieldName] as string).startsWith(prefix),
-        isIndexed
-          ? {
-              field: fieldName,
-              range: IDBKeyRange.bound(prefix, prefix + "\uffff", false, false),
-              type: "range",
-            }
-          : undefined,
-      ),
-
-    anyOf: (values) => {
-      const set = new Set(values);
-      return withFilter((r) => set.has(r[fieldName] as string | number | boolean));
-    },
-
-    noneOf: (values) => {
-      const set = new Set(values);
-      return withFilter((r) => !set.has(r[fieldName] as string | number | boolean));
-    },
-  };
-}
-
-export function createOrderByBuilder<T>(
-  storage: IDBStorageHandle,
-  watchCtx: WatchContext,
-  collectionName: string,
-  def: CollectionDef<CollectionFields>,
-  fieldName: string,
-  mapRecord: (record: Record<string, unknown>) => T,
-): OrderByBuilder<T> {
-  const ctx: QueryContext = { storage, watchCtx, collectionName, def, mapRecord };
-  const plan: QueryPlan = {
-    ...emptyPlan(),
-    orderBy: { field: fieldName, direction: "asc" },
-  };
-  return makeOrderByBuilder(ctx, plan);
-}

package/src/crud/watch.ts

@@ -1,78 +0,0 @@
-import { Effect, PubSub, Ref, Stream } from "effect";
-import type { IDBStorageHandle } from "../storage/idb.ts";
-import type { StorageError } from "../errors.ts";
-
-export interface ChangeEvent {
-  readonly collection: string;
-  readonly recordId: string;
-  readonly kind: "create" | "update" | "delete";
-}
-
-export interface WatchContext {
-  readonly pubsub: PubSub.PubSub<ChangeEvent>;
-  readonly replayingRef: Ref.Ref<boolean>;
-}
-
-/**
- * Create a reactive Stream that emits the current result set whenever it changes.
- */
-export function watchCollection<T>(
-  ctx: WatchContext,
-  storage: IDBStorageHandle,
-  collectionName: string,
-  filter?: (record: Record<string, unknown>) => boolean,
-  mapRecord?: (record: Record<string, unknown>) => T,
-): Stream.Stream<ReadonlyArray<T>, StorageError> {
-  const query = (): Effect.Effect<ReadonlyArray<T>, StorageError> =>
-    Effect.gen(function* () {
-      const all = yield* storage.getAllRecords(collectionName);
-      const filtered = all.filter((r) => !r._deleted && (filter ? filter(r) : true));
-      return mapRecord ? filtered.map(mapRecord) : (filtered as unknown as ReadonlyArray<T>);
-    });
-
-  const changes = Stream.fromPubSub(ctx.pubsub).pipe(
-    Stream.filter((event) => event.collection === collectionName),
-    Stream.mapEffect(() =>
-      Effect.gen(function* () {
-        const replaying = yield* Ref.get(ctx.replayingRef);
-        if (replaying) return undefined;
-        return yield* query();
-      }),
-    ),
-    Stream.filter((result): result is ReadonlyArray<T> => result !== undefined),
-  );
-
-  return Stream.unwrap(
-    Effect.gen(function* () {
-      const initial = yield* query();
-      return Stream.concat(Stream.make(initial), changes);
-    }),
-  );
-}
-
-/**
- * Notify subscribers of a change.
- */
-export function notifyChange(ctx: WatchContext, event: ChangeEvent): Effect.Effect<void> {
-  return PubSub.publish(ctx.pubsub, event).pipe(Effect.asVoid);
-}
-
-/**
- * Emit a replay-complete notification for all collections that changed.
- * Call after sync replay to trigger batched watch updates.
- */
-export function notifyReplayComplete(
-  ctx: WatchContext,
-  collections: ReadonlyArray<string>,
-): Effect.Effect<void> {
-  return Effect.gen(function* () {
-    yield* Ref.set(ctx.replayingRef, false);
-    for (const collection of collections) {
-      yield* notifyChange(ctx, {
-        collection,
-        recordId: "",
-        kind: "update",
-      });
-    }
-  });
-}