ignotum 0.0.2 → 0.0.4

package/src/dev-runtime/database.ts

@@ -1,6 +1,18 @@
 import { Context, DateTime, Effect, Layer, Option, Schema } from "effect";
 import { SqlClient, SqlError, SqlSchema } from "effect/unstable/sql";
-import { GeneratedId, type GeneratedId as GeneratedIdType } from "@ignotum/contracts/runtime/id";
+import {
+  GeneratedId,
+  TableId,
+  type GeneratedId as GeneratedIdType,
+} from "@ignotum/contracts/runtime/id";
+import { IdGenerator } from "@ignotum/shared/id";
+import {
+  AppStateRevision,
+  dependencyKey,
+  documentDependency,
+  tableDependency,
+  type DependencyKey,
+} from "@ignotum/contracts/runtime/hosted";
 import {
   documentNotFound,
   resultFromEffect,
@@ -12,7 +24,8 @@ import type {
   RuntimeTableDefinition,
 } from "@ignotum/contracts/runtime/schema";
 import { SchemaDefinitionTypeId } from "@ignotum/contracts/schema";
-import { IdGenerator } from "@ignotum/runtime/id";
+
+import { DevelopmentDatabase } from "./migrations.js";
 
 interface RuntimeObject {
   readonly [fieldName: string]: RuntimeDocumentValue | undefined;
@@ -58,32 +71,78 @@ export interface LocalMutationContext {
 }
 
 interface LocalDatabaseService {
+  readonly revision: Effect.Effect<AppStateRevision>;
   readonly queryTransaction: <Success, Failure>(
     schema: RuntimeSchemaDefinition,
     use: (context: Readonly<LocalQueryContext>) => Effect.Effect<Success, Failure>,
   ) => Effect.Effect<Success, Failure | SqlError.SqlError>;
+  readonly trackedQueryTransaction: <Success, Failure>(
+    schema: RuntimeSchemaDefinition,
+    use: (context: Readonly<LocalQueryContext>) => Effect.Effect<Success, Failure>,
+  ) => Effect.Effect<
+    {
+      readonly value: Success;
+      readonly dependencies: ReadonlyArray<DependencyKey>;
+      readonly observedRevision: AppStateRevision;
+    },
+    Failure | SqlError.SqlError
+  >;
   readonly mutationTransaction: <Success, Failure>(
     schema: RuntimeSchemaDefinition,
     use: (context: Readonly<LocalMutationContext>) => Effect.Effect<Success, Failure>,
   ) => Effect.Effect<Success, Failure | SqlError.SqlError>;
+  readonly trackedMutationTransaction: <Success, Failure>(
+    schema: RuntimeSchemaDefinition,
+    use: (context: Readonly<LocalMutationContext>) => Effect.Effect<Success, Failure>,
+  ) => Effect.Effect<
+    {
+      readonly value: Success;
+      readonly invalidations: ReadonlyArray<DependencyKey>;
+      readonly committedRevision: AppStateRevision;
+    },
+    Failure | SqlError.SqlError
+  >;
 }
 
 const StoredDocument = Schema.Struct({
   id: GeneratedId,
-  tableName: Schema.String,
   createdAt: Schema.Int,
   updatedAt: Schema.Int,
   fields: Schema.String,
 });
 type StoredDocument = typeof StoredDocument.Type;
 
+const StoredTable = Schema.Struct({ id: TableId, name: Schema.String });
+type StoredTable = typeof StoredTable.Type;
+interface ResolvedTable extends StoredTable {
+  readonly definition: RuntimeTableDefinition;
+}
+
 const DocumentLookup = Schema.Struct({
   id: Schema.String,
-  tableName: Schema.String,
+  tableId: TableId,
 });
-const TableLookup = Schema.Struct({ tableName: Schema.String });
+const TableLookup = Schema.Struct({ tableId: TableId });
+const TableNameLookup = Schema.Struct({ name: Schema.String });
+const TableInsert = Schema.Struct({ id: TableId, name: Schema.String });
+const RevisionRow = Schema.Struct({ revision: AppStateRevision });
 type DatabaseOperation = "collect" | "get" | "insert" | "patch" | "replace";
 
+interface DependencyRecorder {
+  readonly record: (...dependencies: ReadonlyArray<DependencyKey>) => void;
+  readonly values: () => ReadonlyArray<DependencyKey>;
+}
+
+const makeDependencyRecorder = (): DependencyRecorder => {
+  const dependencies = new Map<string, DependencyKey>();
+  return {
+    record: (...added) => {
+      for (const dependency of added) dependencies.set(dependencyKey(dependency), dependency);
+    },
+    values: () => globalThis.Array.from(dependencies.values()),
+  };
+};
+
 export class UnknownDatabaseTable extends Schema.TaggedError<UnknownDatabaseTable>()(
   "UnknownDatabaseTable",
   {
@@ -139,37 +198,37 @@ const fieldsCodec = (table: RuntimeTableDefinition) =>
   );
 
 const encodeFields = Effect.fn("LocalDatabase.encodeFields")(function* (
-  schema: RuntimeSchemaDefinition,
+  table: RuntimeTableDefinition,
   tableName: string,
   value: RuntimeValue,
   operation: Extract<DatabaseOperation, "insert" | "patch" | "replace">,
   id: string | null,
 ) {
-  const table = yield* tableFor(schema, tableName);
   return yield* Schema.encodeEffect(fieldsCodec(table), {
     onExcessProperty: "error",
   })(value).pipe(Effect.mapError((cause) => schemaMismatch(tableName, id, operation, cause)));
 });
 
 const decodeFields = Effect.fn("LocalDatabase.decodeFields")(function* (
-  schema: RuntimeSchemaDefinition,
+  table: RuntimeTableDefinition,
+  tableName: string,
   row: StoredDocument,
   operation: Extract<DatabaseOperation, "collect" | "get" | "patch">,
 ) {
-  const table = yield* tableFor(schema, row.tableName);
   return yield* Schema.decodeEffect(fieldsCodec(table), {
     onExcessProperty: "error",
   })(row.fields).pipe(
-    Effect.mapError((cause) => schemaMismatch(row.tableName, row.id, operation, cause)),
+    Effect.mapError((cause) => schemaMismatch(tableName, row.id, operation, cause)),
   );
 });
 
 const toRuntimeDocument = Effect.fn("LocalDatabase.toRuntimeDocument")(function* (
-  schema: RuntimeSchemaDefinition,
+  table: RuntimeTableDefinition,
+  tableName: string,
   row: StoredDocument,
   operation: Extract<DatabaseOperation, "collect" | "get">,
 ) {
-  const fields = yield* decodeFields(schema, row, operation);
+  const fields = yield* decodeFields(table, tableName, row, operation);
   return {
     ...fields,
     id: row.id,
@@ -188,76 +247,125 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
     LocalDatabase,
     Effect.gen(function* () {
       const ids = yield* IdGenerator;
+      yield* DevelopmentDatabase;
       const sql = yield* SqlClient.SqlClient;
 
-      yield* sql`
-        CREATE TABLE IF NOT EXISTS documents (
-          id TEXT PRIMARY KEY NOT NULL
-            CHECK (length(id) = 24 AND id NOT GLOB '*[^0-9a-z]*'),
-          tableName TEXT NOT NULL,
-          createdAt INTEGER NOT NULL,
-          updatedAt INTEGER NOT NULL,
-          fields TEXT NOT NULL CHECK (json_valid(fields))
-        ) STRICT
-      `;
-      yield* sql`
-        CREATE INDEX IF NOT EXISTS documents_table_name_idx
-        ON documents (tableName)
-      `;
+      const findTable = SqlSchema.findOneOption({
+        Request: TableNameLookup,
+        Result: StoredTable,
+        execute: ({ name }) => sql`
+          SELECT id, name
+          FROM tables
+          WHERE name = ${name}
+          LIMIT 1
+        `,
+      });
+      const insertTable = SqlSchema.findOne({
+        Request: TableInsert,
+        Result: StoredTable,
+        execute: ({ id, name }) => sql`
+          INSERT INTO tables (id, name)
+          VALUES (${id}, ${name})
+          ON CONFLICT (name) DO UPDATE SET name = excluded.name
+          RETURNING id, name
+        `,
+      });
 
       const findStored = SqlSchema.findOneOption({
         Request: DocumentLookup,
         Result: StoredDocument,
-        execute: ({ id, tableName }) => sql`
-          SELECT id, tableName, createdAt, updatedAt, fields
+        execute: ({ id, tableId }) => sql`
+          SELECT id, createdAt, updatedAt, fields
           FROM documents
-          WHERE id = ${id} AND tableName = ${tableName}
+          WHERE id = ${id} AND tableId = ${tableId}
           LIMIT 1
         `,
       });
       const collectStored = SqlSchema.findAll({
         Request: TableLookup,
         Result: StoredDocument,
-        execute: ({ tableName }) => sql`
-          SELECT id, tableName, createdAt, updatedAt, fields
+        execute: ({ tableId }) => sql`
+          SELECT id, createdAt, updatedAt, fields
           FROM documents
-          WHERE tableName = ${tableName}
+          WHERE tableId = ${tableId}
           ORDER BY createdAt ASC, id ASC
         `,
       });
+      const currentRevision = SqlSchema.findOne({
+        Request: Schema.Void,
+        Result: RevisionRow,
+        execute: () => sql`SELECT revision FROM app_state WHERE singleton = 1`,
+      });
+      const advanceRevision = SqlSchema.findOne({
+        Request: Schema.Void,
+        Result: RevisionRow,
+        execute: () => sql`
+          UPDATE app_state
+          SET revision = revision + 1
+          WHERE singleton = 1
+          RETURNING revision
+        `,
+      });
+
+      const resolveTable = Effect.fn("LocalDatabase.resolveTable")(function* (
+        schema: RuntimeSchemaDefinition,
+        name: string,
+      ): Effect.fn.Return<
+        ResolvedTable,
+        UnknownDatabaseTable | SqlError.SqlError | Schema.SchemaError
+      > {
+        const definition = yield* tableFor(schema, name);
+        const existing = yield* findTable({ name });
+        if (Option.isSome(existing)) return { ...existing.value, definition };
+        const id = yield* ids.generate(TableId);
+        const stored = yield* insertTable({ id, name }).pipe(
+          Effect.catchTags({ NoSuchElementError: Effect.die }),
+        );
+        return { ...stored, definition };
+      });
 
       const find = Effect.fn("LocalDatabase.find")(function* (
         schema: RuntimeSchemaDefinition,
         tableName: string,
         id: string,
+        dependencies?: DependencyRecorder,
       ) {
-        yield* tableFor(schema, tableName);
-        const row = yield* findStored({ id, tableName });
+        const table = yield* resolveTable(schema, tableName);
+        const documentId = GeneratedId.make(id);
+        dependencies?.record(documentDependency(table.id, documentId));
+        const row = yield* findStored({ id, tableId: table.id });
         if (Option.isNone(row)) return undefined;
-        return yield* toRuntimeDocument(schema, row.value, "get");
+        return yield* toRuntimeDocument(table.definition, tableName, row.value, "get");
       });
 
       const collect = Effect.fn("LocalDatabase.collect")(function* (
         schema: RuntimeSchemaDefinition,
         tableName: string,
+        dependencies?: DependencyRecorder,
       ) {
-        yield* tableFor(schema, tableName);
-        const rows = yield* collectStored({ tableName });
-        return yield* Effect.forEach(rows, (row) => toRuntimeDocument(schema, row, "collect"));
+        const table = yield* resolveTable(schema, tableName);
+        dependencies?.record(tableDependency(table.id));
+        const rows = yield* collectStored({ tableId: table.id });
+        return yield* Effect.forEach(rows, (row) =>
+          toRuntimeDocument(table.definition, tableName, row, "collect"),
+        );
       });
 
       const insert = Effect.fn("LocalDatabase.insert")(function* (
         schema: RuntimeSchemaDefinition,
         tableName: string,
         value: RuntimeValue,
+        invalidations: DependencyRecorder,
       ) {
-        const fields = yield* encodeFields(schema, tableName, value, "insert", null);
-        const id = yield* ids.generate;
+        const table = yield* resolveTable(schema, tableName);
+        const fields = yield* encodeFields(table.definition, tableName, value, "insert", null);
+        const id = yield* ids.generate(GeneratedId);
         const now = DateTime.toEpochMillis(yield* DateTime.now);
         yield* sql`
-          INSERT INTO documents (id, tableName, createdAt, updatedAt, fields)
-          VALUES (${id}, ${tableName}, ${now}, ${now}, ${fields})
+          INSERT INTO documents (id, tableId, createdAt, updatedAt, fields)
+          VALUES (${id}, ${table.id}, ${now}, ${now}, ${fields})
         `;
+        invalidations.record(tableDependency(table.id), documentDependency(table.id, id));
         return id;
       });
 
@@ -265,9 +373,12 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         schema: RuntimeSchemaDefinition,
         tableName: string,
         id: string,
+        invalidations: DependencyRecorder,
       ) {
-        yield* tableFor(schema, tableName);
-        yield* sql`DELETE FROM documents WHERE id = ${id} AND tableName = ${tableName}`;
+        const table = yield* resolveTable(schema, tableName);
+        const documentId = GeneratedId.make(id);
+        yield* sql`DELETE FROM documents WHERE id = ${id} AND tableId = ${table.id}`;
+        invalidations.record(tableDependency(table.id), documentDependency(table.id, documentId));
       });
 
       const patch = Effect.fn("LocalDatabase.patch")(function* (
@@ -275,24 +386,28 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         tableName: string,
         id: string,
         value: RuntimeValue,
+        invalidations: DependencyRecorder,
       ) {
-        yield* tableFor(schema, tableName);
-        const stored = yield* findStored({ id, tableName });
-        if (Option.isNone(stored)) return;
-        const current = yield* decodeFields(schema, stored.value, "patch");
-        const fields = yield* encodeFields(
-          schema,
-          tableName,
-          { ...current, ...value },
-          "patch",
-          id,
-        );
-        const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
-        yield* sql`
-          UPDATE documents
-          SET fields = ${fields}, updatedAt = ${updatedAt}
-          WHERE id = ${id} AND tableName = ${tableName}
-        `;
+        const table = yield* resolveTable(schema, tableName);
+        const documentId = GeneratedId.make(id);
+        const stored = yield* findStored({ id, tableId: table.id });
+        if (Option.isSome(stored)) {
+          const current = yield* decodeFields(table.definition, tableName, stored.value, "patch");
+          const fields = yield* encodeFields(
+            table.definition,
+            tableName,
+            { ...current, ...value },
+            "patch",
+            id,
+          );
+          const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+          yield* sql`
+            UPDATE documents
+            SET fields = ${fields}, updatedAt = ${updatedAt}
+            WHERE id = ${id} AND tableId = ${table.id}
+          `;
+        }
+        invalidations.record(tableDependency(table.id), documentDependency(table.id, documentId));
       });
 
       const replace = Effect.fn("LocalDatabase.replace")(function* (
@@ -300,26 +415,33 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         tableName: string,
         id: string,
         value: RuntimeValue,
+        invalidations: DependencyRecorder,
       ) {
-        yield* tableFor(schema, tableName);
-        const stored = yield* findStored({ id, tableName });
-        if (Option.isNone(stored)) return;
-        const fields = yield* encodeFields(schema, tableName, value, "replace", id);
-        const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
-        yield* sql`
-          UPDATE documents
-          SET fields = ${fields}, updatedAt = ${updatedAt}
-          WHERE id = ${id} AND tableName = ${tableName}
-        `;
+        const table = yield* resolveTable(schema, tableName);
+        const documentId = GeneratedId.make(id);
+        const stored = yield* findStored({ id, tableId: table.id });
+        if (Option.isSome(stored)) {
+          const fields = yield* encodeFields(table.definition, tableName, value, "replace", id);
+          const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+          yield* sql`
+            UPDATE documents
+            SET fields = ${fields}, updatedAt = ${updatedAt}
+            WHERE id = ${id} AND tableId = ${table.id}
+          `;
+        }
+        invalidations.record(tableDependency(table.id), documentDependency(table.id, documentId));
       });
 
-      const makeReader = (schema: RuntimeSchemaDefinition): LocalDatabaseReader =>
+      const makeReader = (
+        schema: RuntimeSchemaDefinition,
+        dependencies?: DependencyRecorder,
+      ): LocalDatabaseReader =>
         Object.freeze({
           find: (tableName: string, id: string) =>
-            resultFromEffect(find(schema, tableName, id).pipe(Effect.orDie)),
+            resultFromEffect(find(schema, tableName, id, dependencies).pipe(Effect.orDie)),
           get: (tableName: string, id: string) =>
             resultFromEffect(
-              find(schema, tableName, id).pipe(
+              find(schema, tableName, id, dependencies).pipe(
                 Effect.orDie,
                 Effect.flatMap((document) =>
                   document === undefined
@@ -330,44 +452,79 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
             ),
           query: (tableName: string) =>
             Object.freeze({
-              collect: () => resultFromEffect(collect(schema, tableName).pipe(Effect.orDie)),
+              collect: () =>
+                resultFromEffect(collect(schema, tableName, dependencies).pipe(Effect.orDie)),
             }),
         });
 
-      const makeWriter = (schema: RuntimeSchemaDefinition): LocalDatabaseWriter => {
+      const makeWriter = (
+        schema: RuntimeSchemaDefinition,
+        invalidations: DependencyRecorder,
+      ): LocalDatabaseWriter => {
         const reader = makeReader(schema);
         return Object.freeze({
           ...reader,
           delete: (tableName: string, id: string) =>
-            resultFromEffect(deleteDocument(schema, tableName, id).pipe(Effect.orDie)),
+            resultFromEffect(
+              deleteDocument(schema, tableName, id, invalidations).pipe(Effect.orDie),
+            ),
           insert: (tableName: string, value: RuntimeValue) =>
-            resultFromEffect(insert(schema, tableName, value).pipe(Effect.orDie)),
+            resultFromEffect(insert(schema, tableName, value, invalidations).pipe(Effect.orDie)),
           patch: (tableName: string, id: string, value: RuntimeValue) =>
-            resultFromEffect(patch(schema, tableName, id, value).pipe(Effect.orDie)),
+            resultFromEffect(patch(schema, tableName, id, value, invalidations).pipe(Effect.orDie)),
           replace: (tableName: string, id: string, value: RuntimeValue) =>
-            resultFromEffect(replace(schema, tableName, id, value).pipe(Effect.orDie)),
+            resultFromEffect(
+              replace(schema, tableName, id, value, invalidations).pipe(Effect.orDie),
+            ),
         });
       };
 
+      const trackedQueryTransaction: LocalDatabaseService["trackedQueryTransaction"] = (
+        schema,
+        use,
+      ) =>
+        sql.withTransaction(
+          Effect.gen(function* () {
+            const dependencies = makeDependencyRecorder();
+            const context = Object.freeze({
+              db: makeReader(schema, dependencies),
+            });
+            const value = yield* use(context);
+            const { revision: observedRevision } = yield* currentRevision(undefined).pipe(
+              Effect.orDie,
+            );
+            return { value, dependencies: dependencies.values(), observedRevision };
+          }),
+        );
+      const trackedMutationTransaction: LocalDatabaseService["trackedMutationTransaction"] = (
+        schema,
+        use,
+      ) =>
+        sql.withTransaction(
+          Effect.gen(function* () {
+            const invalidations = makeDependencyRecorder();
+            const context = Object.freeze({
+              db: makeWriter(schema, invalidations),
+            });
+            const value = yield* use(context);
+            const { revision: committedRevision } = yield* advanceRevision(undefined).pipe(
+              Effect.orDie,
+            );
+            return { value, invalidations: invalidations.values(), committedRevision };
+          }),
+        );
+
       return LocalDatabase.of({
+        revision: currentRevision(undefined).pipe(
+          Effect.orDie,
+          Effect.map(({ revision }) => revision),
+        ),
         queryTransaction: (schema, use) =>
-          sql.withTransaction(
-            Effect.gen(function* () {
-              const context = Object.freeze({
-                db: makeReader(schema),
-              });
-              return yield* use(context);
-            }),
-          ),
+          trackedQueryTransaction(schema, use).pipe(Effect.map(({ value }) => value)),
+        trackedQueryTransaction,
         mutationTransaction: (schema, use) =>
-          sql.withTransaction(
-            Effect.gen(function* () {
-              const context = Object.freeze({
-                db: makeWriter(schema),
-              });
-              return yield* use(context);
-            }),
-          ),
+          trackedMutationTransaction(schema, use).pipe(Effect.map(({ value }) => value)),
+        trackedMutationTransaction,
       });
     }),
   );

package/src/dev-runtime/dev-database.ts

@@ -1,11 +1,13 @@
-import { Crypto, Effect, FileSystem, Option, Path, Predicate, Schema } from "effect";
+import { DevDatabaseLockId } from "@ignotum/contracts/runtime/id";
+import { IdGenerator } from "@ignotum/shared/id";
+import { Effect, FileSystem, Option, Path, Predicate, Schema } from "effect";
 
 const databaseFileNames = ["state.db", "state.db-shm", "state.db-wal", "state.db-journal"] as const;
 const lockFileName = "lock.json";
 
 const DevDatabaseLockRecord = Schema.Struct({
   pid: Schema.Int,
-  token: Schema.String,
+  token: DevDatabaseLockId,
 });
 const DevDatabaseLockRecordJson = Schema.fromJsonString(DevDatabaseLockRecord);
 type DevDatabaseLockRecord = typeof DevDatabaseLockRecord.Type;
@@ -34,9 +36,9 @@ export class DevDatabaseLockFailed extends Schema.TaggedError<DevDatabaseLockFai
   },
 ) {}
 
-export const devDatabasePath = Effect.fn("DevDatabase.path")(function* (projectDirectory: string) {
+export const devDatabasePath = Effect.fn("DevDatabase.path")(function* (appDirectory: string) {
   const path = yield* Path.Path;
-  return path.join(projectDirectory, ".ignotum", "dev", "state.db");
+  return path.join(appDirectory, ".ignotum", "dev", "state.db");
 });
 
 const processIsRunning = (pid: number): boolean => {
@@ -49,17 +51,17 @@ const processIsRunning = (pid: number): boolean => {
 };
 
 export const acquireDevDatabaseLock = Effect.fn("DevDatabase.acquireLock")(function* (
-  projectDirectory: string,
+  appDirectory: string,
 ) {
-  const crypto = yield* Crypto.Crypto;
+  const ids = yield* IdGenerator;
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const databasePath = yield* devDatabasePath(projectDirectory);
+  const databasePath = yield* devDatabasePath(appDirectory);
   const directory = path.dirname(databasePath);
   const lockPath = path.join(directory, lockFileName);
   const record: DevDatabaseLockRecord = {
     pid: process.pid,
-    token: yield* crypto.randomUUIDv4,
+    token: yield* ids.generate(DevDatabaseLockId),
   };
   const encoded = yield* Schema.encodeEffect(DevDatabaseLockRecordJson)(record).pipe(
     Effect.mapError((cause) =>
@@ -162,16 +164,14 @@ export const acquireDevDatabaseLock = Effect.fn("DevDatabase.acquireLock")(funct
   yield* Effect.acquireRelease(acquire, release);
 });
 
-export const resetDevDatabase = Effect.fn("DevDatabase.reset")(function* (
-  projectDirectory: string,
-) {
+export const resetDevDatabase = Effect.fn("DevDatabase.reset")(function* (appDirectory: string) {
   return yield* Effect.scoped(
     Effect.gen(function* () {
-      yield* acquireDevDatabaseLock(projectDirectory);
+      yield* acquireDevDatabaseLock(appDirectory);
       const fileSystem = yield* FileSystem.FileSystem;
       const path = yield* Path.Path;
-      const directory = path.join(projectDirectory, ".ignotum", "dev");
-      const databasePath = yield* devDatabasePath(projectDirectory);
+      const directory = path.join(appDirectory, ".ignotum", "dev");
+      const databasePath = yield* devDatabasePath(appDirectory);
       let removed = 0;
 
       yield* Effect.forEach(