Remove storage-driver interface; Add state-store as driver-specific implementation

packages/fabric/core/package.json

@@ -1,14 +1,10 @@
 {
   "name": "@fabric/core",
   "type": "module",
-  "module": "dist/index.js",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./domain": "./dist/domain.js",
-    "./validation": "./dist/validation.js",
-    "./validation/fields": "./dist/validation/fields/index.js"
+    ".": "./dist/index.js"
   },
   "files": [
     "dist"

packages/fabric/domain/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@fabric/domain",
   "type": "module",
-  "module": "dist/index.js",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./mocks": "./dist/mocks.js"
+  },
   "files": [
     "dist"
   ],
   "private": true,
   "packageManager": "yarn@4.1.1",
   "devDependencies": {
-    "@fabric/store-sqlite": "workspace:^",
+    "@fabric/sqlite-store": "workspace:^",
     "typescript": "^5.6.2",
     "vitest": "^2.1.1"
   },

packages/fabric/domain/src/events/event-store.ts

@@ -1,36 +1,26 @@
-import { AsyncResult, MaybePromise, PosixDate } from "@fabric/core";
+import { AsyncResult, PosixDate } from "@fabric/core";
 import { StoreQueryError } from "../errors/query-error.js";
-import { UUID } from "../types/uuid.js";
-import { Event, StoredEvent } from "./event.js";
+import { EventsFromStream, EventStream } from "./event-stream.js";
+import { StoredEvent } from "./stored-event.js";
 
-export interface EventStore<TEvent extends Event = Event> {
-  getStream<TEventStreamEvent extends TEvent>(
-    streamId: UUID,
-  ): AsyncResult<EventStream<TEventStreamEvent>, StoreQueryError>;
-
-  appendToStream<TEvent extends Event>(
-    streamId: UUID,
-    events: TEvent,
-  ): AsyncResult<void, StoreQueryError>;
-}
-
-export interface EventStream<TEvent extends Event = Event> {
-  getCurrentVersion(): bigint;
-
-  append(events: TEvent): AsyncResult<StoredEvent<TEvent>, StoreQueryError>;
-
-  subscribe(callback: (event: StoredEvent<TEvent>) => MaybePromise<void>): void;
-
-  getEvents(
-    opts?: EventFilterOptions,
-  ): AsyncResult<StoredEvent<TEvent>[], StoreQueryError>;
+export interface EventStore<TEventStream extends EventStream> {
+  /**
+   * Store a new event in the event store.
+   */
+  append<
+    TStreamKey extends TEventStream["name"],
+    T extends EventsFromStream<TEventStream, TStreamKey>,
+  >(
+    streamName: TStreamKey,
+    event: T,
+  ): AsyncResult<StoredEvent<T>, StoreQueryError>;
 }
 
 export interface EventFilterOptions {
   fromDate?: PosixDate;
   toDate?: PosixDate;
-  fromVersion?: number;
-  toVersion?: number;
+  fromVersion?: bigint;
+  toVersion?: bigint;
   limit?: number;
   offset?: number;
 }

packages/fabric/domain/src/events/event-stream.ts

@@ -0,0 +1,16 @@
+import { AsyncResult } from "@fabric/core";
+import { UUID } from "../types/uuid.js";
+import { Event } from "./event.js";
+import { StoredEvent } from "./stored-event.js";
+
+export interface EventStream<
+  TName extends string = string,
+  TEvent extends Event = Event,
+> {
+  id: UUID;
+  name: TName;
+  append<T extends TEvent>(event: Event): AsyncResult<StoredEvent<T>>;
+}
+
+export type EventsFromStream<T extends EventStream, TKey extends string> =
+  T extends EventStream<TKey, infer TEvent> ? TEvent : never;

packages/fabric/domain/src/events/event.ts

@@ -1,20 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { PosixDate, TaggedVariant } from "@fabric/core";
 import { UUID } from "../types/uuid.js";
 
 /**
  * An event is a tagged variant with a payload and a timestamp.
  */
-export interface Event<TTag extends string = string, TPayload = any>
-  extends TaggedVariant<TTag> {
-  streamId: UUID;
-  payload: TPayload;
+export interface Event<TTag extends string = string, TPayload = any> {
+  readonly type: TTag;
+  readonly id: UUID;
+  readonly streamId: UUID;
+  readonly payload: TPayload;
 }
-
-/**
- * A stored event is an inmutable event, already stored, with it's version in the stream and timestamp.
- */
-export type StoredEvent<TEvent extends Event> = Readonly<TEvent> & {
-  readonly version: number;
-  readonly timestamp: PosixDate;
-};

packages/fabric/domain/src/events/index.ts

@@ -1,2 +1,4 @@
 export * from "./event-store.js";
+export * from "./event-stream.js";
 export * from "./event.js";
+export * from "./stored-event.js";

packages/fabric/domain/src/events/stored-event.ts

@@ -0,0 +1,10 @@
+import { PosixDate } from "@fabric/core";
+import { Event } from "./event.js";
+
+/**
+ * A stored event is an inmutable event, already stored, with it's version in the stream and timestamp.
+ */
+export type StoredEvent<TEvent extends Event> = TEvent & {
+  readonly version: bigint;
+  readonly timestamp: PosixDate;
+};

packages/fabric/domain/src/index.ts

@@ -4,6 +4,5 @@ export * from "./files/index.js";
 export * from "./models/index.js";
 export * from "./security/index.js";
 export * from "./services/index.js";
-export * from "./storage/index.js";
 export * from "./types/index.js";
 export * from "./use-case/index.js";

packages/fabric/domain/src/models/model-schema.ts

@@ -1,7 +1,7 @@
-import { Collection } from "./model.js";
+import { Model } from "./model.js";
 
-export type ModelSchema = Record<string, Collection>;
+export type ModelSchema = Record<string, Model>;
 
-export type ModelSchemaFromModels<TModels extends Collection> = {
+export type ModelSchemaFromModels<TModels extends Model> = {
   [K in TModels["name"]]: Extract<TModels, { name: K }>;
 };

packages/fabric/domain/src/models/query/index.ts

@@ -1,4 +1,3 @@
 export * from "./filter-options.js";
 export * from "./order-by-options.js";
-export * from "./query-builder.js";
 export * from "./query.js";

packages/fabric/domain/src/models/query/query-builder.ts

@@ -1,66 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { AsyncResult, Keyof } from "@fabric/core";
-import { StoreQueryError } from "../../errors/query-error.js";
-import { StorageDriver } from "../../storage/storage-driver.js";
-import { ModelSchema } from "../model-schema.js";
-import { FilterOptions } from "./filter-options.js";
-import { OrderByOptions } from "./order-by-options.js";
-import {
-  QueryDefinition,
-  SelectableQuery,
-  StoreLimitableQuery,
-  StoreQuery,
-  StoreSortableQuery,
-} from "./query.js";
-
-export class QueryBuilder<T> implements StoreQuery<T> {
-  constructor(
-    private driver: StorageDriver,
-    private schema: ModelSchema,
-    private query: QueryDefinition,
-  ) {}
-
-  where(where: FilterOptions<T>): StoreSortableQuery<T> {
-    return new QueryBuilder(this.driver, this.schema, {
-      ...this.query,
-      where,
-    });
-  }
-
-  orderBy(opts: OrderByOptions<T>): StoreLimitableQuery<T> {
-    return new QueryBuilder(this.driver, this.schema, {
-      ...this.query,
-      orderBy: opts,
-    });
-  }
-
-  limit(limit: number, offset?: number | undefined): SelectableQuery<T> {
-    return new QueryBuilder(this.driver, this.schema, {
-      ...this.query,
-      limit,
-      offset,
-    });
-  }
-
-  select(): AsyncResult<T[], StoreQueryError>;
-  select<K extends Keyof<T>>(
-    keys: K[],
-  ): AsyncResult<Pick<T, K>[], StoreQueryError>;
-  select<K extends Keyof<T>>(keys?: K[]): AsyncResult<any, StoreQueryError> {
-    return this.driver.select(this.schema, {
-      ...this.query,
-      keys,
-    });
-  }
-
-  selectOne(): AsyncResult<T, StoreQueryError>;
-  selectOne<K extends Keyof<T>>(
-    keys: K,
-  ): AsyncResult<Pick<T, K>, StoreQueryError>;
-  selectOne<K extends Keyof<T>>(keys?: K[]): AsyncResult<any, StoreQueryError> {
-    return this.driver.selectOne(this.schema, {
-      ...this.query,
-      keys,
-    });
-  }
-}

packages/fabric/domain/src/models/query/query.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { AsyncResult, Keyof } from "@fabric/core";
+import { AsyncResult, Keyof, Optional } from "@fabric/core";
 import { StoreQueryError } from "../../errors/query-error.js";
 import { FilterOptions } from "./filter-options.js";
 import { OrderByOptions } from "./order-by-options.js";
@@ -14,10 +14,10 @@ export interface StoreQuery<T> {
     keys: K[],
   ): AsyncResult<Pick<T, K>[], StoreQueryError>;
 
-  selectOne(): AsyncResult<T, StoreQueryError>;
+  selectOne(): AsyncResult<Optional<T>, StoreQueryError>;
   selectOne<K extends Keyof<T>>(
     keys: K[],
-  ): AsyncResult<Pick<T, K>, StoreQueryError>;
+  ): AsyncResult<Optional<Pick<T, K>>, StoreQueryError>;
 }
 
 export interface StoreSortableQuery<T> {
@@ -29,10 +29,10 @@ export interface StoreSortableQuery<T> {
     keys: K[],
   ): AsyncResult<Pick<T, K>[], StoreQueryError>;
 
-  selectOne(): AsyncResult<T, StoreQueryError>;
+  selectOne(): AsyncResult<Optional<T>, StoreQueryError>;
   selectOne<K extends Keyof<T>>(
     keys: K[],
-  ): AsyncResult<Pick<T, K>, StoreQueryError>;
+  ): AsyncResult<Optional<Pick<T, K>>, StoreQueryError>;
 }
 
 export interface StoreLimitableQuery<T> {
@@ -43,10 +43,10 @@ export interface StoreLimitableQuery<T> {
     keys: K[],
   ): AsyncResult<Pick<T, K>[], StoreQueryError>;
 
-  selectOne(): AsyncResult<T, StoreQueryError>;
+  selectOne(): AsyncResult<Optional<T>, StoreQueryError>;
   selectOne<K extends Keyof<T>>(
     keys: K[],
-  ): AsyncResult<Pick<T, K>, StoreQueryError>;
+  ): AsyncResult<Optional<Pick<T, K>>, StoreQueryError>;
 }
 
 export interface SelectableQuery<T> {
@@ -55,10 +55,10 @@ export interface SelectableQuery<T> {
     keys: K[],
   ): AsyncResult<Pick<T, K>[], StoreQueryError>;
 
-  selectOne(): AsyncResult<T, StoreQueryError>;
+  selectOne(): AsyncResult<Optional<T>, StoreQueryError>;
   selectOne<K extends Keyof<T>>(
     keys: K[],
-  ): AsyncResult<Pick<T, K>, StoreQueryError>;
+  ): AsyncResult<Optional<Pick<T, K>>, StoreQueryError>;
 }
 
 export interface QueryDefinition<K extends string = string> {

packages/fabric/domain/src/models/state-store.spec.ts

@@ -1,136 +0,0 @@
-import { isError, Run } from "@fabric/core";
-import { SQLiteStorageDriver } from "@fabric/store-sqlite";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  expectTypeOf,
-  it,
-} from "vitest";
-import { UUIDGeneratorMock } from "../services/uuid-generator.mock.js";
-import { UUID } from "../types/uuid.js";
-import { Field } from "./fields/index.js";
-import { defineModel } from "./model.js";
-import { isLike } from "./query/filter-options.js";
-import { StateStore } from "./state-store.js";
-
-describe("State Store", () => {
-  const models = [
-    defineModel("users", {
-      name: Field.string(),
-    }),
-  ];
-
-  let driver: SQLiteStorageDriver;
-  let store: StateStore<(typeof models)[number]>;
-
-  beforeEach(async () => {
-    driver = new SQLiteStorageDriver(":memory:");
-    store = new StateStore(driver, models);
-    const migrationResult = await store.migrate();
-    if (isError(migrationResult)) throw migrationResult;
-  });
-
-  afterEach(async () => {
-    await driver.close();
-  });
-
-  it("should insert a record", async () => {
-    const newUUID = UUIDGeneratorMock.generate();
-    const insertResult = await store.insertInto("users", {
-      name: "test",
-      id: newUUID,
-      streamId: newUUID,
-      streamVersion: 1n,
-    });
-    if (isError(insertResult)) throw insertResult;
-  });
-
-  it("should query with a basic select", async () => {
-    const newUUID = UUIDGeneratorMock.generate();
-    const insertResult = await store.insertInto("users", {
-      name: "test",
-      id: newUUID,
-      streamId: newUUID,
-      streamVersion: 1n,
-    });
-
-    if (isError(insertResult)) throw insertResult;
-
-    const result = (await store.from("users").select()).unwrapOrThrow();
-
-    expectTypeOf(result).toEqualTypeOf<
-      {
-        id: UUID;
-        streamId: UUID;
-        streamVersion: bigint;
-        name: string;
-      }[]
-    >();
-
-    expect(result).toEqual([
-      {
-        id: newUUID,
-        streamId: newUUID,
-        streamVersion: 1n,
-        name: "test",
-      },
-    ]);
-  });
-
-  it("should query with a where clause", async () => {
-    const newUUID = UUIDGeneratorMock.generate();
-
-    await Run.seqUNSAFE(
-      () =>
-        store.insertInto("users", {
-          name: "test",
-          id: newUUID,
-          streamId: newUUID,
-          streamVersion: 1n,
-        }),
-      () =>
-        store.insertInto("users", {
-          name: "anotherName",
-          id: UUIDGeneratorMock.generate(),
-          streamId: UUIDGeneratorMock.generate(),
-          streamVersion: 1n,
-        }),
-      () =>
-        store.insertInto("users", {
-          name: "anotherName2",
-          id: UUIDGeneratorMock.generate(),
-          streamId: UUIDGeneratorMock.generate(),
-          streamVersion: 1n,
-        }),
-    );
-
-    const result = await Run.UNSAFE(() =>
-      store
-        .from("users")
-        .where({
-          name: isLike("te%"),
-        })
-        .select(),
-    );
-
-    expectTypeOf(result).toEqualTypeOf<
-      {
-        id: UUID;
-        streamId: UUID;
-        streamVersion: bigint;
-        name: string;
-      }[]
-    >();
-
-    expect(result).toEqual([
-      {
-        id: newUUID,
-        streamId: newUUID,
-        streamVersion: 1n,
-        name: "test",
-      },
-    ]);
-  });
-});

packages/fabric/domain/src/models/state-store.ts

@@ -1,42 +1,19 @@
 import { AsyncResult } from "@fabric/core";
-import { CircularDependencyError } from "../errors/circular-dependency-error.js";
 import { StoreQueryError } from "../errors/query-error.js";
-import { StorageDriver } from "../storage/storage-driver.js";
 import { ModelSchemaFromModels } from "./model-schema.js";
 import { Model, ModelToType } from "./model.js";
-import { QueryBuilder } from "./query/query-builder.js";
 import { StoreQuery } from "./query/query.js";
 
-export class StateStore<TModel extends Model> {
-  private schema: ModelSchemaFromModels<TModel>;
-  constructor(
-    private driver: StorageDriver,
-    models: TModel[],
-  ) {
-    this.schema = models.reduce((acc, model: TModel) => {
-      return {
-        ...acc,
-        [model.name]: model,
-      };
-    }, {} as ModelSchemaFromModels<TModel>);
-  }
-
-  migrate(): AsyncResult<void, StoreQueryError | CircularDependencyError> {
-    return this.driver.sync(this.schema);
-  }
-
-  async insertInto<T extends keyof ModelSchemaFromModels<TModel>>(
-    collection: T,
-    record: ModelToType<ModelSchemaFromModels<TModel>[T]>,
-  ): AsyncResult<void, StoreQueryError> {
-    return this.driver.insert(this.schema[collection], record);
-  }
-
+export interface ReadonlyStateStore<TModel extends Model> {
   from<T extends keyof ModelSchemaFromModels<TModel>>(
     collection: T,
-  ): StoreQuery<ModelToType<ModelSchemaFromModels<TModel>[T]>> {
-    return new QueryBuilder(this.driver, this.schema, {
-      from: collection,
-    }) as StoreQuery<ModelToType<ModelSchemaFromModels<TModel>[T]>>;
+  ): StoreQuery<ModelToType<ModelSchemaFromModels<TModel>[T]>>;
 }
+
+export interface WritableStateStore<TModel extends Model>
+  extends ReadonlyStateStore<TModel> {
+  insertInto<T extends keyof ModelSchemaFromModels<TModel>>(
+    collection: T,
+    record: ModelToType<ModelSchemaFromModels<TModel>[T]>,
+  ): AsyncResult<void, StoreQueryError>;
 }

packages/fabric/domain/src/storage/index.ts

@@ -1 +0,0 @@
-export * from "./storage-driver.js";

packages/fabric/domain/src/storage/storage-driver.ts

@@ -1,65 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { AsyncResult, UnexpectedError } from "@fabric/core";
-import { CircularDependencyError } from "../errors/circular-dependency-error.js";
-import { StoreQueryError } from "../errors/query-error.js";
-import { ModelSchema } from "../models/model-schema.js";
-import { Collection } from "../models/model.js";
-import { QueryDefinition } from "../models/query/query.js";
-
-export interface StorageDriver {
-  /**
-   * Insert data into the store
-   */
-  insert(
-    model: Collection,
-    record: Record<string, any>,
-  ): AsyncResult<void, StoreQueryError>;
-
-  /**
-   * Run a select query against the store.
-   */
-  select(
-    model: ModelSchema,
-    query: QueryDefinition,
-  ): AsyncResult<any[], StoreQueryError>;
-
-  /**
-   * Run a select query against the store.
-   */
-  selectOne(
-    model: ModelSchema,
-    query: QueryDefinition,
-  ): AsyncResult<any, StoreQueryError>;
-
-  /**
-   * Sincronice the store with the schema.
-   */
-  sync(
-    schema: ModelSchema,
-  ): AsyncResult<void, StoreQueryError | CircularDependencyError>;
-
-  /**
-   * Drop the store. This is a destructive operation.
-   */
-  drop(): AsyncResult<void, StoreQueryError>;
-
-  /**
-   * Close the store.
-   */
-  close(): AsyncResult<void, UnexpectedError>;
-
-  /**
-   * Update a record in the store.
-   */
-  update(
-    model: Collection,
-    id: string,
-    record: Record<string, any>,
-  ): AsyncResult<void, StoreQueryError>;
-
-  /**
-   * Delete a record from the store.
-   */
-  delete(model: Collection, id: string): AsyncResult<void, StoreQueryError>;
-}

packages/fabric/store-sqlite/package.json

@@ -1,8 +1,11 @@
 {
-  "name": "@fabric/store-sqlite",
+  "name": "@fabric/sqlite-store",
   "type": "module",
-  "module": "dist/index.js",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "files": [
     "dist"
   ],

packages/fabric/store-sqlite/src/index.ts

@@ -1 +1 @@
-export * from "./sqlite-driver.js";
+export * from "./state/index.js";

packages/fabric/store-sqlite/src/sqlite-driver.spec.ts

@@ -1,251 +0,0 @@
-import { isError } from "@fabric/core";
-import { defineModel, Field, isLike } from "@fabric/domain";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { SQLiteStorageDriver } from "./sqlite-driver.js";
-
-describe("SQLite Store Driver", () => {
-  const schema = {
-    demo: defineModel("demo", {
-      value: Field.float(),
-      owner: Field.reference({ targetModel: "users" }),
-    }),
-    users: defineModel("users", {
-      name: Field.string(),
-    }),
-  };
-
-  let driver: SQLiteStorageDriver;
-
-  beforeEach(() => {
-    driver = new SQLiteStorageDriver(":memory:");
-  });
-
-  afterEach(async () => {
-    const result = await driver.close();
-    if (isError(result)) throw result;
-  });
-
-  it("should synchronize the store and insert a record", async () => {
-    const result = await driver.sync(schema);
-
-    if (isError(result)) throw result;
-
-    const insertResult = await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-
-    if (isError(insertResult)) throw insertResult;
-
-    const records = (
-      await driver.select(schema, { from: "users" })
-    ).unwrapOrThrow();
-
-    expect(records).toEqual([
-      { id: "1", name: "test", streamId: "1", streamVersion: 1n },
-    ]);
-  });
-
-  it("should be update a record", async () => {
-    await driver.sync(schema);
-
-    await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-
-    const err = await driver.update(schema.users, "1", { name: "updated" });
-    if (isError(err)) throw err;
-
-    const records = (
-      await driver.select(schema, { from: "users" })
-    ).unwrapOrThrow();
-
-    expect(records).toEqual([
-      { id: "1", name: "updated", streamId: "1", streamVersion: 1n },
-    ]);
-  });
-
-  it("should be able to delete a record", async () => {
-    await driver.sync(schema);
-
-    await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-
-    await driver.delete(schema.users, "1");
-
-    const records = (
-      await driver.select(schema, { from: "users" })
-    ).unwrapOrThrow();
-
-    expect(records).toEqual([]);
-  });
-
-  it("should be able to select records", async () => {
-    await driver.sync(schema);
-
-    await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-    await driver.insert(schema.users, {
-      id: "2",
-      name: "test",
-      streamId: "2",
-      streamVersion: 1n,
-    });
-
-    const records = (
-      await driver.select(schema, { from: "users" })
-    ).unwrapOrThrow();
-
-    expect(records).toEqual([
-      { id: "1", name: "test", streamId: "1", streamVersion: 1n },
-      { id: "2", name: "test", streamId: "2", streamVersion: 1n },
-    ]);
-  });
-
-  it("should be able to select one record", async () => {
-    await driver.sync(schema);
-
-    await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-    await driver.insert(schema.users, {
-      id: "2",
-      name: "test",
-      streamId: "2",
-      streamVersion: 1n,
-    });
-
-    const record = (
-      await driver.selectOne(schema, { from: "users" })
-    ).unwrapOrThrow();
-
-    expect(record).toEqual({
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-  });
-
-  it("should select a record with a where clause", async () => {
-    await driver.sync(schema);
-
-    await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-    await driver.insert(schema.users, {
-      id: "2",
-      name: "jamón",
-      streamId: "2",
-      streamVersion: 1n,
-    });
-
-    const result = (
-      await driver.select(schema, {
-        from: "users",
-        where: { name: isLike("te%") },
-      })
-    ).unwrapOrThrow();
-
-    expect(result).toEqual([
-      {
-        id: "1",
-        name: "test",
-        streamId: "1",
-        streamVersion: 1n,
-      },
-    ]);
-  });
-
-  it("should select a record with a where clause of a specific type", async () => {
-    await driver.sync(schema);
-
-    await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-    await driver.insert(schema.users, {
-      id: "2",
-      name: "jamón",
-      streamId: "2",
-      streamVersion: 1n,
-    });
-
-    const result = (
-      await driver.select(schema, {
-        from: "users",
-        where: { streamVersion: 1n },
-      })
-    ).unwrapOrThrow();
-
-    expect(result).toEqual([
-      {
-        id: "1",
-        name: "test",
-        streamId: "1",
-        streamVersion: 1n,
-      },
-      {
-        id: "2",
-        name: "jamón",
-        streamId: "2",
-        streamVersion: 1n,
-      },
-    ]);
-  });
-
-  it("should select with a limit and offset", async () => {
-    await driver.sync(schema);
-
-    await driver.insert(schema.users, {
-      id: "1",
-      name: "test",
-      streamId: "1",
-      streamVersion: 1n,
-    });
-    await driver.insert(schema.users, {
-      id: "2",
-      name: "jamón",
-      streamId: "2",
-      streamVersion: 1n,
-    });
-
-    const result = (
-      await driver.select(schema, {
-        from: "users",
-        limit: 1,
-        offset: 1,
-      })
-    ).unwrapOrThrow();
-
-    expect(result).toEqual([
-      {
-        id: "2",
-        name: "jamón",
-        streamId: "2",
-        streamVersion: 1n,
-      },
-    ]);
-  });
-});

packages/fabric/store-sqlite/src/sqlite-driver.ts

@@ -1,257 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { AsyncResult, UnexpectedError } from "@fabric/core";
-import { unlink } from "fs/promises";
-
-import {
-  CircularDependencyError,
-  Collection,
-  Model,
-  ModelSchema,
-  QueryDefinition,
-  StorageDriver,
-  StoreQueryError,
-} from "@fabric/domain";
-import { Database, Statement } from "sqlite3";
-import { filterToParams, filterToSQL } from "./filter-to-sql.js";
-import { modelToSql } from "./model-to-sql.js";
-import {
-  keyToParam,
-  recordToSQLKeyParams,
-  recordToSQLKeys,
-  recordToSQLParams,
-  recordToSQLSet,
-} from "./record-utils.js";
-import { transformRow } from "./sql-to-value.js";
-import {
-  dbClose,
-  dbRun,
-  finalize,
-  getAll,
-  getOne,
-  prepare,
-  run,
-} from "./sqlite-wrapper.js";
-
-export class SQLiteStorageDriver implements StorageDriver {
-  private db: Database;
-
-  private cachedStatements = new Map<string, Statement>();
-
-  constructor(private path: string) {
-    this.db = new Database(path);
-  }
-
-  /**
-   * Get a statement from the cache or prepare a new one.
-   */
-  private async getOrCreatePreparedStatement(sql: string): Promise<Statement> {
-    if (this.cachedStatements.has(sql)) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- We know it's there.
-      return this.cachedStatements.get(sql)!;
-    }
-
-    const stmt = await prepare(this.db, sql);
-    this.cachedStatements.set(sql, stmt);
-
-    return stmt;
-  }
-
-  private async getSelectStatement(
-    collection: Collection,
-    query: QueryDefinition,
-  ): Promise<[Statement, Record<string, any>]> {
-    const selectFields = query.keys ? query.keys.join(", ") : "*";
-
-    const queryFilter = filterToSQL(query.where);
-    const limit = query.limit ? `LIMIT ${query.limit}` : "";
-    const offset = query.offset ? `OFFSET ${query.offset}` : "";
-
-    const sql = [
-      `SELECT ${selectFields}`,
-      `FROM ${query.from}`,
-      queryFilter,
-      limit,
-      offset,
-    ].join(" ");
-
-    return [
-      await this.getOrCreatePreparedStatement(sql),
-      {
-        ...filterToParams(collection, query.where),
-      },
-    ];
-  }
-
-  /**
-   * Insert data into the store
-   */
-  async insert(
-    model: Model,
-    record: Record<string, any>,
-  ): AsyncResult<void, StoreQueryError> {
-    return AsyncResult.tryFrom(
-      async () => {
-        const sql = `INSERT INTO ${model.name} (${recordToSQLKeys(record)}) VALUES (${recordToSQLKeyParams(record)})`;
-        const stmt = await this.getOrCreatePreparedStatement(sql);
-        return await run(stmt, recordToSQLParams(model, record));
-      },
-      (error) =>
-        new StoreQueryError(error.message, {
-          error,
-          collectionName: model.name,
-          record,
-        }),
-    );
-  }
-
-  /**
-   * Run a select query against the store.
-   */
-  async select(
-    schema: ModelSchema,
-    query: QueryDefinition,
-  ): AsyncResult<any[], StoreQueryError> {
-    return AsyncResult.tryFrom(
-      async () => {
-        const [stmt, params] = await this.getSelectStatement(
-          schema[query.from],
-          query,
-        );
-        return await getAll(stmt, params, transformRow(schema[query.from]));
-      },
-      (err) =>
-        new StoreQueryError(err.message, {
-          err,
-          query,
-        }),
-    );
-  }
-
-  /**
-   * Run a select query against the store.
-   */
-  async selectOne(
-    schema: ModelSchema,
-    query: QueryDefinition,
-  ): AsyncResult<any, StoreQueryError> {
-    return AsyncResult.tryFrom(
-      async () => {
-        const [stmt, params] = await this.getSelectStatement(
-          schema[query.from],
-          query,
-        );
-        return await getOne(stmt, params, transformRow(schema[query.from]));
-      },
-      (err) =>
-        new StoreQueryError(err.message, {
-          err,
-          query,
-        }),
-    );
-  }
-
-  /**
-   * Sincronice the store with the schema.
-   */
-  async sync(
-    schema: ModelSchema,
-  ): AsyncResult<void, StoreQueryError | CircularDependencyError> {
-    return AsyncResult.tryFrom(
-      async () => {
-        // Enable Write-Ahead Logging, which is faster and more reliable.
-        await dbRun(this.db, "PRAGMA journal_mode = WAL;");
-
-        // Enable foreign key constraints.
-        await dbRun(this.db, "PRAGMA foreign_keys = ON;");
-
-        // Begin a transaction to create the schema.
-        await dbRun(this.db, "BEGIN TRANSACTION;");
-        for (const modelKey in schema) {
-          const model = schema[modelKey];
-          await dbRun(this.db, modelToSql(model));
-        }
-        await dbRun(this.db, "COMMIT;");
-      },
-      (error) =>
-        new StoreQueryError(error.message, {
-          error,
-          schema,
-        }),
-    );
-  }
-
-  /**
-   * Drop the store. This is a destructive operation.
-   */
-  async drop(): AsyncResult<void, StoreQueryError> {
-    return AsyncResult.tryFrom(
-      async () => {
-        if (this.path === ":memory:") {
-          throw "Cannot drop in-memory database";
-        } else {
-          await unlink(this.path);
-        }
-      },
-      (error) =>
-        new StoreQueryError(error.message, {
-          error,
-        }),
-    );
-  }
-
-  async close(): AsyncResult<void, UnexpectedError> {
-    return AsyncResult.from(async () => {
-      for (const stmt of this.cachedStatements.values()) {
-        await finalize(stmt);
-      }
-      await dbClose(this.db);
-    });
-  }
-
-  /**
-   * Update a record in the store.
-   */
-  async update(
-    model: Model,
-    id: string,
-    record: Record<string, any>,
-  ): AsyncResult<void, StoreQueryError> {
-    return AsyncResult.tryFrom(
-      async () => {
-        const sql = `UPDATE ${model.name} SET ${recordToSQLSet(record)} WHERE id = ${keyToParam("id")}`;
-        const stmt = await this.getOrCreatePreparedStatement(sql);
-        const params = recordToSQLParams(model, {
-          ...record,
-          id,
-        });
-        return await run(stmt, params);
-      },
-      (error) =>
-        new StoreQueryError(error.message, {
-          error,
-          collectionName: model.name,
-          record,
-        }),
-    );
-  }
-
-  /**
-   * Delete a record from the store.
-   */
-
-  async delete(model: Model, id: string): AsyncResult<void, StoreQueryError> {
-    return AsyncResult.tryFrom(
-      async () => {
-        const sql = `DELETE FROM ${model.name} WHERE id = ${keyToParam("id")}`;
-        const stmt = await this.getOrCreatePreparedStatement(sql);
-        return await run(stmt, { [keyToParam("id")]: id });
-      },
-      (error) =>
-        new StoreQueryError(error.message, {
-          error,
-          collectionName: model.name,
-          id,
-        }),
-    );
-  }
-}

packages/fabric/store-sqlite/src/sqlite-wrapper.ts

@@ -1,97 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Database, Statement } from "sqlite3";
-
-export function dbRun(db: Database, statement: string): Promise<any> {
-  return new Promise((resolve, reject) => {
-    db.all(statement, (err, result) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(result);
-      }
-    });
-  });
-}
-
-export function dbClose(db: Database): Promise<void> {
-  return new Promise((resolve, reject) => {
-    db.close((err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve();
-      }
-    });
-  });
-}
-
-export function prepare(db: Database, statement: string): Promise<Statement> {
-  return new Promise((resolve, reject) => {
-    const stmt = db.prepare(statement, (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(stmt);
-      }
-    });
-  });
-}
-
-export function run(
-  stmt: Statement,
-  params: Record<string, any>,
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    stmt.run(params, (err: Error | null) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve();
-      }
-    });
-  });
-}
-
-export function getAll(
-  stmt: Statement,
-  params: Record<string, any>,
-  transformer: (row: any) => any,
-): Promise<Record<string, any>[]> {
-  return new Promise((resolve, reject) => {
-    stmt.all(params, (err: Error | null, rows: Record<string, any>[]) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(rows.map(transformer));
-      }
-    });
-  });
-}
-
-export function getOne(
-  stmt: Statement,
-  params: Record<string, any>,
-  transformer: (row: any) => any,
-): Promise<Record<string, any>> {
-  return new Promise((resolve, reject) => {
-    stmt.all(params, (err: Error | null, rows: Record<string, any>[]) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(rows.map(transformer)[0]);
-      }
-    });
-  });
-}
-
-export function finalize(stmt: Statement): Promise<void> {
-  return new Promise((resolve, reject) => {
-    stmt.finalize((err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve();
-      }
-    });
-  });
-}

packages/fabric/store-sqlite/src/sqlite/model-to-sql.ts

@@ -1,8 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Variant, VariantTag } from "@fabric/core";
 import { Collection, FieldDefinition, getTargetKey } from "@fabric/domain";
-import { EmbeddedField } from "@fabric/domain/dist/models/fields/embedded.js";
-import { TimestampField } from "@fabric/domain/dist/models/fields/timestamp.js";
 
 type FieldSQLDefinitionMap = {
   [K in FieldDefinition[VariantTag]]: (
@@ -42,10 +40,10 @@ const FieldSQLDefinitionMap: FieldSQLDefinitionMap = {
   DecimalField: (n, f): string => {
     return [n, "REAL", modifiersFromOpts(f)].join(" ");
   },
-  TimestampField: (n, f: TimestampField): string => {
+  TimestampField: (n, f): string => {
     return [n, "NUMERIC", modifiersFromOpts(f)].join(" ");
   },
-  EmbeddedField: (n, f: EmbeddedField): string => {
+  EmbeddedField: (n, f): string => {
     return [n, "TEXT", modifiersFromOpts(f)].join(" ");
   },
 };

packages/fabric/store-sqlite/src/sqlite/sqlite-wrapper.ts

@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { MaybePromise } from "@fabric/core";
+import SQLite from "sqlite3";
+
+export class SQLiteDatabase {
+  db: SQLite.Database;
+
+  private cachedStatements = new Map<string, SQLite.Statement>();
+
+  constructor(private readonly path: string) {
+    this.db = new SQLite.Database(path);
+  }
+
+  async init() {
+    await this.run("PRAGMA journal_mode = WAL");
+    await this.run("PRAGMA foreign_keys = ON");
+  }
+
+  async close() {
+    await this.finalizeStatements();
+    await new Promise<void>((resolve, reject) => {
+      this.db.close((err: Error | null) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  async withTransaction(fn: () => MaybePromise<void>) {
+    try {
+      await this.run("BEGIN TRANSACTION");
+      await fn();
+      await this.run("COMMIT");
+    } catch {
+      await this.run("ROLLBACK");
+    }
+  }
+
+  run(sql: string, params?: Record<string, any>) {
+    return new Promise<void>((resolve, reject) => {
+      this.db.run(sql, params, (err: Error | null) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  runPrepared(sql: string, params?: Record<string, any>) {
+    const cachedStmt = this.getCachedStatement(sql);
+
+    return new Promise<void>((resolve, reject) => {
+      cachedStmt.run(params, (err: Error | null) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  allPrepared(
+    sql: string,
+    params?: Record<string, any>,
+    transformer?: (row: any) => any,
+  ) {
+    const cachedStmt = this.getCachedStatement(sql);
+
+    return new Promise<any>((resolve, reject) => {
+      cachedStmt.all(
+        params,
+        (err: Error | null, rows: Record<string, any>[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(transformer ? rows.map(transformer) : rows);
+          }
+        },
+      );
+    });
+  }
+
+  onePrepared(
+    sql: string,
+    params?: Record<string, any>,
+    transformer?: (row: any) => any,
+  ) {
+    const cachedStmt = this.getCachedStatement(sql);
+
+    return new Promise<any>((resolve, reject) => {
+      cachedStmt.all(
+        params,
+        (err: Error | null, rows: Record<string, any>[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(transformer ? rows.map(transformer)[0] : rows[0]);
+          }
+        },
+      );
+    });
+  }
+
+  private getCachedStatement(sql: string) {
+    let cached = this.cachedStatements.get(sql);
+
+    if (!cached) {
+      const stmt = this.db.prepare(sql);
+      this.cachedStatements.set(sql, stmt);
+      cached = stmt;
+    }
+    return cached;
+  }
+
+  private async finalizeStatements() {
+    for (const stmt of this.cachedStatements.values()) {
+      await new Promise<void>((resolve, reject) => {
+        stmt.finalize((err: Error | null) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+  }
+}

packages/fabric/store-sqlite/src/state/index.ts

@@ -0,0 +1 @@
+export * from "./state-store.js";

packages/fabric/store-sqlite/src/state/query-builder.ts

@@ -0,0 +1,127 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AsyncResult, Keyof, Optional } from "@fabric/core";
+import {
+  Collection,
+  FilterOptions,
+  ModelSchema,
+  OrderByOptions,
+  QueryDefinition,
+  SelectableQuery,
+  StoreLimitableQuery,
+  StoreQuery,
+  StoreQueryError,
+  StoreSortableQuery,
+} from "@fabric/domain";
+import { filterToParams, filterToSQL } from "../sqlite/filter-to-sql.js";
+import { transformRow } from "../sqlite/sql-to-value.js";
+import { SQLiteDatabase } from "../sqlite/sqlite-wrapper.js";
+
+export class QueryBuilder<T> implements StoreQuery<T> {
+  constructor(
+    private db: SQLiteDatabase,
+    private schema: ModelSchema,
+    private query: QueryDefinition,
+  ) {}
+
+  where(where: FilterOptions<T>): StoreSortableQuery<T> {
+    return new QueryBuilder(this.db, this.schema, {
+      ...this.query,
+      where,
+    });
+  }
+
+  orderBy(opts: OrderByOptions<T>): StoreLimitableQuery<T> {
+    return new QueryBuilder(this.db, this.schema, {
+      ...this.query,
+      orderBy: opts,
+    });
+  }
+
+  limit(limit: number, offset?: number | undefined): SelectableQuery<T> {
+    return new QueryBuilder(this.db, this.schema, {
+      ...this.query,
+      limit,
+      offset,
+    });
+  }
+
+  select(): AsyncResult<T[], StoreQueryError>;
+  select<K extends Keyof<T>>(
+    keys: K[],
+  ): AsyncResult<Pick<T, K>[], StoreQueryError>;
+  select<K extends Keyof<T>>(keys?: K[]): AsyncResult<any, StoreQueryError> {
+    return AsyncResult.tryFrom(
+      async () => {
+        const [sql, params] = getSelectStatement(this.schema[this.query.from], {
+          ...this.query,
+          keys,
+        });
+        return this.db.allPrepared(
+          sql,
+          params,
+          transformRow(this.schema[this.query.from]),
+        );
+      },
+      (err) =>
+        new StoreQueryError(err.message, {
+          err,
+          query: this.query,
+        }),
+    );
+  }
+
+  selectOne(): AsyncResult<Optional<T>, StoreQueryError>;
+  selectOne<K extends Keyof<T>>(
+    keys: K,
+  ): AsyncResult<Optional<Pick<T, K>>, StoreQueryError>;
+  selectOne<K extends Keyof<T>>(keys?: K[]): AsyncResult<any, StoreQueryError> {
+    return AsyncResult.tryFrom(
+      async () => {
+        const [stmt, params] = getSelectStatement(
+          this.schema[this.query.from],
+          {
+            ...this.query,
+            keys,
+            limit: 1,
+          },
+        );
+        return await this.db.onePrepared(
+          stmt,
+          params,
+          transformRow(this.schema[this.query.from]),
+        );
+      },
+      (err) =>
+        new StoreQueryError(err.message, {
+          err,
+          query: this.query,
+        }),
+    );
+  }
+}
+
+export function getSelectStatement(
+  collection: Collection,
+  query: QueryDefinition,
+): [string, Record<string, any>] {
+  const selectFields = query.keys ? query.keys.join(", ") : "*";
+
+  const queryFilter = filterToSQL(query.where);
+  const limit = query.limit ? `LIMIT ${query.limit}` : "";
+  const offset = query.offset ? `OFFSET ${query.offset}` : "";
+
+  const sql = [
+    `SELECT ${selectFields}`,
+    `FROM ${query.from}`,
+    queryFilter,
+    limit,
+    offset,
+  ].join(" ");
+
+  return [
+    sql,
+    {
+      ...filterToParams(collection, query.where),
+    },
+  ];
+}

packages/fabric/store-sqlite/src/state/state-store.spec.ts

@@ -0,0 +1,213 @@
+import { Run } from "@fabric/core";
+import { defineModel, Field, isLike, UUID } from "@fabric/domain";
+import { UUIDGeneratorMock } from "@fabric/domain/mocks";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  expectTypeOf,
+  it,
+} from "vitest";
+import { SQLiteStateStore } from "./state-store.js";
+
+describe("State Store", () => {
+  const models = [
+    defineModel("demo", {
+      value: Field.float(),
+      owner: Field.reference({ targetModel: "users" }),
+    }),
+    defineModel("users", {
+      name: Field.string(),
+    }),
+  ];
+
+  let store: SQLiteStateStore<(typeof models)[number]>;
+
+  beforeEach(async () => {
+    store = new SQLiteStateStore(":memory:", models);
+    await Run.UNSAFE(() => store.migrate());
+  });
+
+  afterEach(async () => {
+    await Run.UNSAFE(() => store.close());
+  });
+
+  it("should insert a record", async () => {
+    const newUUID = UUIDGeneratorMock.generate();
+
+    await Run.UNSAFE(() =>
+      store.insertInto("users", {
+        id: newUUID,
+        name: "test",
+        streamId: newUUID,
+        streamVersion: 1n,
+      }),
+    );
+  });
+
+  it("should select all records", async () => {
+    const newUUID = UUIDGeneratorMock.generate();
+
+    await Run.UNSAFE(() =>
+      store.insertInto("users", {
+        name: "test",
+        id: newUUID,
+        streamId: newUUID,
+        streamVersion: 1n,
+      }),
+    );
+
+    const result = await Run.UNSAFE(() => store.from("users").select());
+
+    expectTypeOf(result).toEqualTypeOf<
+      {
+        id: UUID;
+        streamId: UUID;
+        streamVersion: bigint;
+        name: string;
+      }[]
+    >();
+
+    expect(result).toEqual([
+      {
+        id: newUUID,
+        streamId: newUUID,
+        streamVersion: 1n,
+        name: "test",
+      },
+    ]);
+  });
+
+  it("should select records with a filter", async () => {
+    const newUUID = UUIDGeneratorMock.generate();
+
+    await Run.seqUNSAFE(
+      () =>
+        store.insertInto("users", {
+          name: "test",
+          id: newUUID,
+          streamId: newUUID,
+          streamVersion: 1n,
+        }),
+      () =>
+        store.insertInto("users", {
+          name: "anotherName",
+          id: UUIDGeneratorMock.generate(),
+          streamId: UUIDGeneratorMock.generate(),
+          streamVersion: 1n,
+        }),
+      () =>
+        store.insertInto("users", {
+          name: "anotherName2",
+          id: UUIDGeneratorMock.generate(),
+          streamId: UUIDGeneratorMock.generate(),
+          streamVersion: 1n,
+        }),
+    );
+
+    const result = await Run.UNSAFE(() =>
+      store
+        .from("users")
+        .where({
+          name: isLike("te%"),
+        })
+        .select(),
+    );
+
+    expectTypeOf(result).toEqualTypeOf<
+      {
+        id: UUID;
+        streamId: UUID;
+        streamVersion: bigint;
+        name: string;
+      }[]
+    >();
+
+    expect(result).toEqual([
+      {
+        id: newUUID,
+        streamId: newUUID,
+        streamVersion: 1n,
+        name: "test",
+      },
+    ]);
+  });
+
+  it("should update a record", async () => {
+    const newUUID = UUIDGeneratorMock.generate();
+
+    await Run.UNSAFE(() =>
+      store.insertInto("users", {
+        name: "test",
+        id: newUUID,
+        streamId: newUUID,
+        streamVersion: 1n,
+      }),
+    );
+
+    await Run.UNSAFE(() =>
+      store.update("users", newUUID, {
+        name: "updated",
+      }),
+    );
+
+    const result = await Run.UNSAFE(() =>
+      store.from("users").where({ id: newUUID }).selectOne(),
+    );
+
+    expect(result).toEqual({
+      id: newUUID,
+      streamId: newUUID,
+      streamVersion: 1n,
+      name: "updated",
+    });
+  });
+
+  it("should delete a record", async () => {
+    const newUUID = UUIDGeneratorMock.generate();
+
+    await Run.UNSAFE(() =>
+      store.insertInto("users", {
+        name: "test",
+        id: newUUID,
+        streamId: newUUID,
+        streamVersion: 1n,
+      }),
+    );
+
+    await Run.UNSAFE(() => store.delete("users", newUUID));
+
+    const result = await Run.UNSAFE(() =>
+      store.from("users").where({ id: newUUID }).selectOne(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  //test for inserting into a collection with a reference
+
+  it("should insert a record with a reference", async () => {
+    const newUUID = UUIDGeneratorMock.generate();
+    const ownerUUID = UUIDGeneratorMock.generate();
+
+    await Run.UNSAFE(() =>
+      store.insertInto("users", {
+        id: ownerUUID,
+        name: "test",
+        streamId: ownerUUID,
+        streamVersion: 1n,
+      }),
+    );
+
+    await Run.UNSAFE(() =>
+      store.insertInto("demo", {
+        id: newUUID,
+        value: 1.0,
+        owner: ownerUUID,
+        streamId: newUUID,
+        streamVersion: 1n,
+      }),
+    );
+  });
+});

packages/fabric/store-sqlite/src/state/state-store.ts

@@ -0,0 +1,144 @@
+import { AsyncResult, UnexpectedError } from "@fabric/core";
+import {
+  Model,
+  ModelSchemaFromModels,
+  ModelToType,
+  StoreQuery,
+  StoreQueryError,
+  UUID,
+  WritableStateStore,
+} from "@fabric/domain";
+import { modelToSql } from "../sqlite/model-to-sql.js";
+import {
+  keyToParam,
+  recordToSQLKeyParams,
+  recordToSQLKeys,
+  recordToSQLParams,
+  recordToSQLSet,
+} from "../sqlite/record-utils.js";
+import { SQLiteDatabase } from "../sqlite/sqlite-wrapper.js";
+import { QueryBuilder } from "./query-builder.js";
+
+export class SQLiteStateStore<TModel extends Model>
+  implements WritableStateStore<TModel>
+{
+  private schema: ModelSchemaFromModels<TModel>;
+  private db: SQLiteDatabase;
+
+  constructor(
+    private dbPath: string,
+    models: TModel[],
+  ) {
+    this.schema = models.reduce((acc, model: TModel) => {
+      return {
+        ...acc,
+        [model.name]: model,
+      };
+    }, {} as ModelSchemaFromModels<TModel>);
+
+    this.db = new SQLiteDatabase(dbPath);
+  }
+
+  async insertInto<T extends keyof ModelSchemaFromModels<TModel>>(
+    collection: T,
+    record: ModelToType<ModelSchemaFromModels<TModel>[T]>,
+  ): AsyncResult<void, StoreQueryError> {
+    const model = this.schema[collection];
+
+    return AsyncResult.tryFrom(
+      async () => {
+        await this.db.runPrepared(
+          `INSERT INTO ${model.name} (${recordToSQLKeys(record)}) VALUES (${recordToSQLKeyParams(record)})`,
+          recordToSQLParams(model, record),
+        );
+      },
+      (error) =>
+        new StoreQueryError(error.message, {
+          error,
+          collectionName: model.name,
+          record,
+        }),
+    );
+  }
+
+  from<T extends keyof ModelSchemaFromModels<TModel>>(
+    collection: T,
+  ): StoreQuery<ModelToType<ModelSchemaFromModels<TModel>[T]>> {
+    return new QueryBuilder(this.db, this.schema, {
+      from: collection,
+    }) as StoreQuery<ModelToType<ModelSchemaFromModels<TModel>[T]>>;
+  }
+
+  update<T extends keyof ModelSchemaFromModels<TModel>>(
+    collection: T,
+    id: UUID,
+    record: Partial<ModelToType<ModelSchemaFromModels<TModel>[T]>>,
+  ): AsyncResult<void, StoreQueryError> {
+    const model = this.schema[collection];
+
+    return AsyncResult.tryFrom(
+      async () => {
+        const params = recordToSQLParams(model, {
+          ...record,
+          id,
+        });
+        await this.db.runPrepared(
+          `UPDATE ${model.name} SET ${recordToSQLSet(record)} WHERE id = ${keyToParam("id")}`,
+          params,
+        );
+      },
+      (error) =>
+        new StoreQueryError(error.message, {
+          error,
+          collectionName: model.name,
+          record,
+        }),
+    );
+  }
+
+  delete<T extends keyof ModelSchemaFromModels<TModel>>(
+    collection: T,
+    id: UUID,
+  ): AsyncResult<void, StoreQueryError> {
+    const model = this.schema[collection];
+
+    return AsyncResult.tryFrom(
+      async () => {
+        await this.db.runPrepared(
+          `DELETE FROM ${model.name} WHERE id = ${keyToParam("id")}`,
+          { $id: id },
+        );
+      },
+      (error) =>
+        new StoreQueryError(error.message, {
+          error,
+          collectionName: model.name,
+          id,
+        }),
+    );
+  }
+
+  migrate(): AsyncResult<void, StoreQueryError> {
+    return AsyncResult.tryFrom(
+      async () => {
+        await this.db.init();
+        await this.db.withTransaction(async () => {
+          for (const modelKey in this.schema) {
+            const model =
+              this.schema[modelKey as keyof ModelSchemaFromModels<TModel>];
+            await this.db.runPrepared(modelToSql(model));
+          }
+        });
+      },
+      (error) =>
+        new StoreQueryError(error.message, {
+          error,
+          schema: this.schema,
+        }),
+    );
+  }
+
+  async close(): AsyncResult<void, UnexpectedError> {
+    return AsyncResult.from(() => this.db.close());
+  }
+}

packages/templates/lib/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@ulthar/lib-template",
   "type": "module",
-  "module": "dist/index.js",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "files": [
     "dist"
   ],

yarn.lock

@@ -419,16 +419,16 @@ __metadata:
   resolution: "@fabric/domain@workspace:packages/fabric/domain"
   dependencies:
     "@fabric/core": "workspace:^"
-    "@fabric/store-sqlite": "workspace:^"
+    "@fabric/sqlite-store": "workspace:^"
     decimal.js: "npm:^10.4.3"
     typescript: "npm:^5.6.2"
     vitest: "npm:^2.1.1"
   languageName: unknown
   linkType: soft
 
-"@fabric/store-sqlite@workspace:^, @fabric/store-sqlite@workspace:packages/fabric/store-sqlite":
+"@fabric/sqlite-store@workspace:^, @fabric/sqlite-store@workspace:packages/fabric/store-sqlite":
   version: 0.0.0-use.local
-  resolution: "@fabric/store-sqlite@workspace:packages/fabric/store-sqlite"
+  resolution: "@fabric/sqlite-store@workspace:packages/fabric/store-sqlite"
   dependencies:
     "@fabric/core": "workspace:^"
     "@fabric/domain": "workspace:^"