ignotum 0.0.0 → 0.0.2

package/src/dev-runtime/database.ts

@@ -0,0 +1,374 @@
+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 {
+  documentNotFound,
+  resultFromEffect,
+  type DocumentNotFoundValue,
+  type Result,
+} from "@ignotum/contracts/runtime/result";
+import type {
+  RuntimeSchemaDefinition,
+  RuntimeTableDefinition,
+} from "@ignotum/contracts/runtime/schema";
+import { SchemaDefinitionTypeId } from "@ignotum/contracts/schema";
+import { IdGenerator } from "@ignotum/runtime/id";
+
+interface RuntimeObject {
+  readonly [fieldName: string]: RuntimeDocumentValue | undefined;
+}
+type RuntimeDocumentValue =
+  | null
+  | boolean
+  | number
+  | string
+  | Date
+  | ReadonlyArray<RuntimeDocumentValue>
+  | RuntimeObject;
+type RuntimeValue = RuntimeObject;
+
+export interface RuntimeDocument {
+  readonly [fieldName: string]: RuntimeDocumentValue | undefined;
+  readonly id: GeneratedIdType;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+}
+
+export interface LocalDatabaseReader {
+  readonly find: (tableName: string, id: string) => Result<RuntimeDocument | undefined, never>;
+  readonly get: (tableName: string, id: string) => Result<RuntimeDocument, DocumentNotFoundValue>;
+  readonly query: (tableName: string) => {
+    readonly collect: () => Result<ReadonlyArray<RuntimeDocument>, never>;
+  };
+}
+
+export interface LocalDatabaseWriter extends LocalDatabaseReader {
+  readonly delete: (tableName: string, id: string) => Result<void, never>;
+  readonly insert: (tableName: string, value: RuntimeValue) => Result<GeneratedIdType, never>;
+  readonly patch: (tableName: string, id: string, value: RuntimeValue) => Result<void, never>;
+  readonly replace: (tableName: string, id: string, value: RuntimeValue) => Result<void, never>;
+}
+
+export interface LocalQueryContext {
+  readonly db: LocalDatabaseReader;
+}
+
+export interface LocalMutationContext {
+  readonly db: LocalDatabaseWriter;
+}
+
+interface LocalDatabaseService {
+  readonly queryTransaction: <Success, Failure>(
+    schema: RuntimeSchemaDefinition,
+    use: (context: Readonly<LocalQueryContext>) => Effect.Effect<Success, Failure>,
+  ) => Effect.Effect<Success, Failure | SqlError.SqlError>;
+  readonly mutationTransaction: <Success, Failure>(
+    schema: RuntimeSchemaDefinition,
+    use: (context: Readonly<LocalMutationContext>) => Effect.Effect<Success, Failure>,
+  ) => Effect.Effect<Success, 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 DocumentLookup = Schema.Struct({
+  id: Schema.String,
+  tableName: Schema.String,
+});
+const TableLookup = Schema.Struct({ tableName: Schema.String });
+type DatabaseOperation = "collect" | "get" | "insert" | "patch" | "replace";
+
+export class UnknownDatabaseTable extends Schema.TaggedError<UnknownDatabaseTable>()(
+  "UnknownDatabaseTable",
+  {
+    message: Schema.String,
+    tableName: Schema.String,
+  },
+) {}
+
+export class DocumentSchemaMismatch extends Schema.TaggedError<DocumentSchemaMismatch>()(
+  "DocumentSchemaMismatch",
+  {
+    cause: Schema.Defect(),
+    id: Schema.NullOr(Schema.String),
+    message: Schema.String,
+    operation: Schema.Literals(["collect", "get", "insert", "patch", "replace"]),
+    tableName: Schema.String,
+  },
+) {}
+
+const schemaMismatch = (
+  tableName: string,
+  id: string | null,
+  operation: DatabaseOperation,
+  cause: unknown,
+) =>
+  DocumentSchemaMismatch.make({
+    cause,
+    id,
+    message: `Document fields for ${tableName} did not match its schema during ${operation}.`,
+    operation,
+    tableName,
+  });
+
+const tableFor = Effect.fn("LocalDatabase.tableFor")(function* (
+  schema: RuntimeSchemaDefinition,
+  tableName: string,
+) {
+  const table = schema[SchemaDefinitionTypeId][tableName];
+  if (table === undefined) {
+    return yield* UnknownDatabaseTable.make({
+      message: `Unknown database table ${tableName}.`,
+      tableName,
+    });
+  }
+  return table;
+});
+
+const fieldsCodec = (table: RuntimeTableDefinition) =>
+  // SAFETY: defineSchema creates every table schema with Schema.Struct, so its
+  // decoded value is a string-keyed object and the authoring API needs no services.
+  Schema.fromJsonString(
+    Schema.make<Schema.Codec<RuntimeValue, Schema.Json>>(Schema.toCodecJson(table.schema).ast),
+  );
+
+const encodeFields = Effect.fn("LocalDatabase.encodeFields")(function* (
+  schema: RuntimeSchemaDefinition,
+  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,
+  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)),
+  );
+});
+
+const toRuntimeDocument = Effect.fn("LocalDatabase.toRuntimeDocument")(function* (
+  schema: RuntimeSchemaDefinition,
+  row: StoredDocument,
+  operation: Extract<DatabaseOperation, "collect" | "get">,
+) {
+  const fields = yield* decodeFields(schema, row, operation);
+  return {
+    ...fields,
+    id: row.id,
+    createdAt: DateTime.toDate(DateTime.makeUnsafe(row.createdAt)),
+    updatedAt: DateTime.toDate(DateTime.makeUnsafe(row.updatedAt)),
+  } satisfies RuntimeDocument;
+});
+
+const nextUpdatedAt = (now: DateTime.DateTime, previous: number): number =>
+  Math.max(DateTime.toEpochMillis(now), previous + 1);
+
+export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseService>()(
+  "ignotum/dev-runtime/database/LocalDatabase",
+) {
+  static readonly layer = Layer.effect(
+    LocalDatabase,
+    Effect.gen(function* () {
+      const ids = yield* IdGenerator;
+      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 findStored = SqlSchema.findOneOption({
+        Request: DocumentLookup,
+        Result: StoredDocument,
+        execute: ({ id, tableName }) => sql`
+          SELECT id, tableName, createdAt, updatedAt, fields
+          FROM documents
+          WHERE id = ${id} AND tableName = ${tableName}
+          LIMIT 1
+        `,
+      });
+      const collectStored = SqlSchema.findAll({
+        Request: TableLookup,
+        Result: StoredDocument,
+        execute: ({ tableName }) => sql`
+          SELECT id, tableName, createdAt, updatedAt, fields
+          FROM documents
+          WHERE tableName = ${tableName}
+          ORDER BY createdAt ASC, id ASC
+        `,
+      });
+
+      const find = Effect.fn("LocalDatabase.find")(function* (
+        schema: RuntimeSchemaDefinition,
+        tableName: string,
+        id: string,
+      ) {
+        yield* tableFor(schema, tableName);
+        const row = yield* findStored({ id, tableName });
+        if (Option.isNone(row)) return undefined;
+        return yield* toRuntimeDocument(schema, row.value, "get");
+      });
+
+      const collect = Effect.fn("LocalDatabase.collect")(function* (
+        schema: RuntimeSchemaDefinition,
+        tableName: string,
+      ) {
+        yield* tableFor(schema, tableName);
+        const rows = yield* collectStored({ tableName });
+        return yield* Effect.forEach(rows, (row) => toRuntimeDocument(schema, row, "collect"));
+      });
+
+      const insert = Effect.fn("LocalDatabase.insert")(function* (
+        schema: RuntimeSchemaDefinition,
+        tableName: string,
+        value: RuntimeValue,
+      ) {
+        const fields = yield* encodeFields(schema, tableName, value, "insert", null);
+        const id = yield* ids.generate;
+        const now = DateTime.toEpochMillis(yield* DateTime.now);
+        yield* sql`
+          INSERT INTO documents (id, tableName, createdAt, updatedAt, fields)
+          VALUES (${id}, ${tableName}, ${now}, ${now}, ${fields})
+        `;
+        return id;
+      });
+
+      const deleteDocument = Effect.fn("LocalDatabase.delete")(function* (
+        schema: RuntimeSchemaDefinition,
+        tableName: string,
+        id: string,
+      ) {
+        yield* tableFor(schema, tableName);
+        yield* sql`DELETE FROM documents WHERE id = ${id} AND tableName = ${tableName}`;
+      });
+
+      const patch = Effect.fn("LocalDatabase.patch")(function* (
+        schema: RuntimeSchemaDefinition,
+        tableName: string,
+        id: string,
+        value: RuntimeValue,
+      ) {
+        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 replace = Effect.fn("LocalDatabase.replace")(function* (
+        schema: RuntimeSchemaDefinition,
+        tableName: string,
+        id: string,
+        value: RuntimeValue,
+      ) {
+        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 makeReader = (schema: RuntimeSchemaDefinition): LocalDatabaseReader =>
+        Object.freeze({
+          find: (tableName: string, id: string) =>
+            resultFromEffect(find(schema, tableName, id).pipe(Effect.orDie)),
+          get: (tableName: string, id: string) =>
+            resultFromEffect(
+              find(schema, tableName, id).pipe(
+                Effect.orDie,
+                Effect.flatMap((document) =>
+                  document === undefined
+                    ? Effect.fail(documentNotFound(tableName, id))
+                    : Effect.succeed(document),
+                ),
+              ),
+            ),
+          query: (tableName: string) =>
+            Object.freeze({
+              collect: () => resultFromEffect(collect(schema, tableName).pipe(Effect.orDie)),
+            }),
+        });
+
+      const makeWriter = (schema: RuntimeSchemaDefinition): LocalDatabaseWriter => {
+        const reader = makeReader(schema);
+        return Object.freeze({
+          ...reader,
+          delete: (tableName: string, id: string) =>
+            resultFromEffect(deleteDocument(schema, tableName, id).pipe(Effect.orDie)),
+          insert: (tableName: string, value: RuntimeValue) =>
+            resultFromEffect(insert(schema, tableName, value).pipe(Effect.orDie)),
+          patch: (tableName: string, id: string, value: RuntimeValue) =>
+            resultFromEffect(patch(schema, tableName, id, value).pipe(Effect.orDie)),
+          replace: (tableName: string, id: string, value: RuntimeValue) =>
+            resultFromEffect(replace(schema, tableName, id, value).pipe(Effect.orDie)),
+        });
+      };
+
+      return LocalDatabase.of({
+        queryTransaction: (schema, use) =>
+          sql.withTransaction(
+            Effect.gen(function* () {
+              const context = Object.freeze({
+                db: makeReader(schema),
+              });
+              return yield* use(context);
+            }),
+          ),
+        mutationTransaction: (schema, use) =>
+          sql.withTransaction(
+            Effect.gen(function* () {
+              const context = Object.freeze({
+                db: makeWriter(schema),
+              });
+              return yield* use(context);
+            }),
+          ),
+      });
+    }),
+  );
+}

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

@@ -0,0 +1,199 @@
+import { Crypto, 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,
+});
+const DevDatabaseLockRecordJson = Schema.fromJsonString(DevDatabaseLockRecord);
+type DevDatabaseLockRecord = typeof DevDatabaseLockRecord.Type;
+
+export class DevDatabaseResetFailed extends Schema.TaggedError<DevDatabaseResetFailed>()(
+  "DevDatabaseResetFailed",
+  {
+    cause: Schema.Defect(),
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export class DevDatabaseInUse extends Schema.TaggedError<DevDatabaseInUse>()("DevDatabaseInUse", {
+  message: Schema.String,
+  path: Schema.String,
+  pid: Schema.Int,
+}) {}
+
+export class DevDatabaseLockFailed extends Schema.TaggedError<DevDatabaseLockFailed>()(
+  "DevDatabaseLockFailed",
+  {
+    cause: Schema.Defect(),
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export const devDatabasePath = Effect.fn("DevDatabase.path")(function* (projectDirectory: string) {
+  const path = yield* Path.Path;
+  return path.join(projectDirectory, ".ignotum", "dev", "state.db");
+});
+
+const processIsRunning = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (cause) {
+    return !(Predicate.hasProperty(cause, "code") && cause.code === "ESRCH");
+  }
+};
+
+export const acquireDevDatabaseLock = Effect.fn("DevDatabase.acquireLock")(function* (
+  projectDirectory: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const databasePath = yield* devDatabasePath(projectDirectory);
+  const directory = path.dirname(databasePath);
+  const lockPath = path.join(directory, lockFileName);
+  const record: DevDatabaseLockRecord = {
+    pid: process.pid,
+    token: yield* crypto.randomUUIDv4,
+  };
+  const encoded = yield* Schema.encodeEffect(DevDatabaseLockRecordJson)(record).pipe(
+    Effect.mapError((cause) =>
+      DevDatabaseLockFailed.make({
+        cause,
+        message: `Could not encode the development database lock at ${lockPath}.`,
+        path: lockPath,
+      }),
+    ),
+  );
+
+  yield* fileSystem.makeDirectory(directory, { recursive: true }).pipe(
+    Effect.mapError((cause) =>
+      DevDatabaseLockFailed.make({
+        cause,
+        message: `Could not create the development state directory at ${directory}.`,
+        path: lockPath,
+      }),
+    ),
+  );
+
+  const createLock = () =>
+    fileSystem.writeFileString(lockPath, encoded, { flag: "wx" }).pipe(
+      Effect.matchEffect({
+        onFailure: (cause) =>
+          cause.reason._tag === "AlreadyExists"
+            ? Effect.succeed(false)
+            : DevDatabaseLockFailed.make({
+                cause,
+                message: `Could not create the development database lock at ${lockPath}.`,
+                path: lockPath,
+              }),
+        onSuccess: () => Effect.succeed(true),
+      }),
+    );
+
+  const readLock = Effect.fn("DevDatabase.readLock")(function* () {
+    const content = yield* fileSystem.readFileString(lockPath).pipe(
+      Effect.mapError((cause) =>
+        DevDatabaseLockFailed.make({
+          cause,
+          message: `Could not read the development database lock at ${lockPath}.`,
+          path: lockPath,
+        }),
+      ),
+    );
+    return yield* Schema.decodeEffect(DevDatabaseLockRecordJson)(content).pipe(
+      Effect.mapError((cause) =>
+        DevDatabaseLockFailed.make({
+          cause,
+          message: `The development database lock at ${lockPath} is invalid. Remove it and try again.`,
+          path: lockPath,
+        }),
+      ),
+    );
+  });
+
+  const failInUse = (current: DevDatabaseLockRecord) =>
+    DevDatabaseInUse.make({
+      message: `Another Ignotum development server is using ${databasePath} with process ${current.pid}.`,
+      path: lockPath,
+      pid: current.pid,
+    });
+
+  const acquire = Effect.gen(function* () {
+    if (yield* createLock()) return record;
+
+    const current = yield* readLock();
+    if (processIsRunning(current.pid)) return yield* failInUse(current);
+
+    yield* fileSystem.remove(lockPath).pipe(
+      Effect.mapError((cause) =>
+        DevDatabaseLockFailed.make({
+          cause,
+          message: `Could not remove the stale development database lock at ${lockPath}.`,
+          path: lockPath,
+        }),
+      ),
+    );
+
+    if (yield* createLock()) return record;
+    return yield* failInUse(yield* readLock());
+  });
+
+  const release = (owned: DevDatabaseLockRecord) =>
+    Effect.gen(function* () {
+      if (!(yield* fileSystem.exists(lockPath))) return;
+      const content = yield* fileSystem.readFileString(lockPath);
+      const current = Schema.decodeOption(DevDatabaseLockRecordJson)(content);
+      if (Option.isNone(current) || current.value.token !== owned.token) return;
+      yield* fileSystem.remove(lockPath);
+    }).pipe(
+      Effect.catchCause((cause) =>
+        Effect.logWarning(`Could not release the development database lock at ${lockPath}.`).pipe(
+          Effect.annotateLogs({ cause }),
+        ),
+      ),
+    );
+
+  yield* Effect.acquireRelease(acquire, release);
+});
+
+export const resetDevDatabase = Effect.fn("DevDatabase.reset")(function* (
+  projectDirectory: string,
+) {
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      yield* acquireDevDatabaseLock(projectDirectory);
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const directory = path.join(projectDirectory, ".ignotum", "dev");
+      const databasePath = yield* devDatabasePath(projectDirectory);
+      let removed = 0;
+
+      yield* Effect.forEach(
+        databaseFileNames,
+        Effect.fn("DevDatabase.removeFile")(function* (fileName) {
+          const filePath = path.join(directory, fileName);
+          if (!(yield* fileSystem.exists(filePath))) return;
+          yield* fileSystem.remove(filePath);
+          removed += 1;
+        }),
+        { discard: true },
+      ).pipe(
+        Effect.mapError((cause) =>
+          DevDatabaseResetFailed.make({
+            cause,
+            message: `Could not reset ${databasePath}. Stop the Ignotum dev server and try again.`,
+            path: databasePath,
+          }),
+        ),
+      );
+
+      return { databasePath, removed } as const;
+    }),
+  );
+});