ignotum 0.0.2 → 0.0.4

package/src/dev-runtime/functions.ts

@@ -6,12 +6,11 @@ import {
   type FunctionKind,
   type FunctionResolutionError,
 } from "@ignotum/contracts/runtime/functions";
-import {
-  getFunctionSchema,
-  type FunctionSchemaCarrier,
-  type RuntimeSchemaDefinition,
-} from "@ignotum/contracts/runtime/schema";
+import { type RuntimeSchemaDefinition } from "@ignotum/contracts/runtime/schema";
 import { ErrorValueSchema, type ErrorValue } from "@ignotum/contracts/runtime/result";
+import { RequestId } from "@ignotum/contracts/runtime/id";
+import { IdGenerator } from "@ignotum/shared/id";
+import type { RuntimeInvocationResult } from "@ignotum/contracts/runtime/hosted";
 import {
   FunctionAddress,
   apiFunctionParts,
@@ -22,34 +21,21 @@ import {
 } from "@ignotum/contracts/runtime/sync";
 import { FunctionRuntime } from "@ignotum/runtime/functions";
 import { Cause, Context, Effect, Layer, Path, Predicate, Schema, Semaphore } from "effect";
-import { nanoid } from "nanoid";
 import type { ViteDevServer } from "vite";
 import { normalizePath } from "vite";
 
 import { LocalDatabase, type LocalMutationContext, type LocalQueryContext } from "./database.js";
+import {
+  inspectRuntimeFunctionDefinition,
+  type FunctionArguments,
+  type RuntimeFunctionDefinition as InternalRuntimeFunctionDefinition,
+} from "../internal/function-definition.js";
 
 export { FunctionUnavailable, InvalidArguments, UnknownFunction, WrongFunctionKind };
-export type { FunctionKind };
-
-type RuntimeFields = Readonly<Record<string, Schema.ConstraintDecoder<unknown>>>;
-
-declare const FunctionArgumentsTypeId: unique symbol;
-export interface FunctionArguments {
-  readonly [FunctionArgumentsTypeId]?: never;
-}
+export type { FunctionArguments, FunctionKind };
 
 export type RuntimeHandlerContext = LocalMutationContext | LocalQueryContext;
-
-export interface RuntimeFunctionDefinition {
-  readonly _tag: FunctionKind;
-  readonly args?: RuntimeFields;
-  readonly returns?: Schema.Codec<unknown, unknown>;
-  readonly errors?: Schema.Codec<unknown, unknown>;
-  readonly handler: (
-    context: RuntimeHandlerContext,
-    args: FunctionArguments,
-  ) => Generator<Effect.Effect<unknown, ErrorValue, never>, TransportValue | void, never>;
-}
+export type RuntimeFunctionDefinition = InternalRuntimeFunctionDefinition<RuntimeHandlerContext>;
 
 export interface ResolvedFunction {
   readonly definition: RuntimeFunctionDefinition;
@@ -57,52 +43,6 @@ export interface ResolvedFunction {
   readonly schema: RuntimeSchemaDefinition;
 }
 
-interface RuntimeFunctionCandidate extends FunctionSchemaCarrier {
-  readonly _tag?: unknown;
-  readonly args?: unknown;
-  readonly returns?: unknown;
-  readonly errors?: unknown;
-  readonly handler?: unknown;
-}
-
-const inspectRuntimeFunctionDefinition = (
-  value: RuntimeFunctionCandidate,
-):
-  | { readonly definition: RuntimeFunctionDefinition; readonly schema: RuntimeSchemaDefinition }
-  | undefined => {
-  const schema = getFunctionSchema(value);
-  if (
-    schema === undefined ||
-    !Predicate.hasProperty(value, "_tag") ||
-    (value._tag !== "Mutation" && value._tag !== "Query") ||
-    (Predicate.hasProperty(value, "args") &&
-      value.args !== undefined &&
-      !Predicate.isObject(value.args)) ||
-    (Predicate.hasProperty(value, "returns") &&
-      value.returns !== undefined &&
-      !Schema.isSchema(value.returns)) ||
-    (Predicate.hasProperty(value, "errors") &&
-      value.errors !== undefined &&
-      !Schema.isSchema(value.errors)) ||
-    !Predicate.hasProperty(value, "handler") ||
-    !Predicate.isFunction(value.handler)
-  ) {
-    return undefined;
-  }
-
-  if (
-    Predicate.hasProperty(value, "args") &&
-    Predicate.isObject(value.args) &&
-    !Object.values(value.args).every(Schema.isSchema)
-  ) {
-    return undefined;
-  }
-
-  // SAFETY: every RuntimeFunctionDefinition property and argument Schema was
-  // checked above. Predicate.hasProperty does not retain the literal tag type.
-  return { definition: value as RuntimeFunctionDefinition, schema };
-};
-
 export class FunctionRegistry extends Context.Service<
   FunctionRegistry,
   {
@@ -113,7 +53,7 @@ export class FunctionRegistry extends Context.Service<
     ) => Effect.Effect<ResolvedFunction, FunctionResolutionError>;
   }
 >()("ignotum/dev-runtime/functions/FunctionRegistry") {
-  static layer(server: ViteDevServer, projectDirectory: string) {
+  static layer(server: ViteDevServer, appDirectory: string) {
     return Layer.effect(
       FunctionRegistry,
       Effect.gen(function* () {
@@ -121,9 +61,7 @@ export class FunctionRegistry extends Context.Service<
         return FunctionRegistry.of({
           resolve: Effect.fn("FunctionRegistry.resolve")(function* (functionAddress, kind, args) {
             const { functionName, moduleName } = apiFunctionParts(functionAddress);
-            const modulePath = normalizePath(
-              path.join(projectDirectory, "server", `${moduleName}.ts`),
-            );
+            const modulePath = normalizePath(path.join(appDirectory, "server", `${moduleName}.ts`));
             const loadedModule = yield* Effect.tryPromise({
               try: () => server.ssrLoadModule(modulePath),
               catch: (cause) =>
@@ -136,7 +74,7 @@ export class FunctionRegistry extends Context.Service<
             const candidate = loadedModule[functionName];
 
             const inspected = Predicate.isObject(candidate)
-              ? inspectRuntimeFunctionDefinition(candidate)
+              ? inspectRuntimeFunctionDefinition<RuntimeHandlerContext>(candidate)
               : undefined;
             if (inspected === undefined) {
               return yield* UnknownFunction.make({
@@ -186,13 +124,14 @@ export class FunctionExecutor extends Context.Service<
       functionAddress: FunctionAddress,
       kind: FunctionKind,
       resolved: ResolvedFunction,
-    ) => Effect.Effect<WireResult>;
+    ) => Effect.Effect<RuntimeInvocationResult>;
   }
 >()("ignotum/dev-runtime/functions/FunctionExecutor") {
   static readonly layer = Layer.effect(
     FunctionExecutor,
     Effect.gen(function* () {
       const database = yield* LocalDatabase;
+      const ids = yield* IdGenerator;
       const mutationSemaphore = yield* Semaphore.make(1);
 
       const encodeSuccess = (
@@ -235,10 +174,19 @@ export class FunctionExecutor extends Context.Service<
 
           const execution =
             kind === "Query"
-              ? database.queryTransaction(resolved.schema, invoke)
+              ? database.trackedQueryTransaction(resolved.schema, invoke).pipe(
+                  Effect.map(
+                    ({ dependencies, observedRevision, value }): RuntimeInvocationResult => ({
+                      type: "Query",
+                      result: value,
+                      dependencies,
+                      observedRevision,
+                    }),
+                  ),
+                )
               : mutationSemaphore.withPermits(1)(
                   database
-                    .mutationTransaction(resolved.schema, (context) =>
+                    .trackedMutationTransaction(resolved.schema, (context) =>
                       invoke(context).pipe(
                         Effect.flatMap((result) =>
                           result.type === "Failure"
@@ -248,9 +196,20 @@ export class FunctionExecutor extends Context.Service<
                       ),
                     )
                     .pipe(
+                      Effect.map(
+                        ({ committedRevision, invalidations, value }): RuntimeInvocationResult => ({
+                          type: "Mutation",
+                          result: value,
+                          invalidations,
+                          committedRevision,
+                        }),
+                      ),
                       Effect.catchTags({
                         MutationApplicationFailure: ({ error }) =>
-                          Effect.succeed({ type: "Failure" as const, error }),
+                          Effect.succeed<RuntimeInvocationResult>({
+                            type: "Mutation",
+                            result: { type: "Failure", error },
+                          }),
                       }),
                     ),
                 );
@@ -259,16 +218,26 @@ export class FunctionExecutor extends Context.Service<
             Effect.orDie,
             Effect.catchCauseIf(
               (cause) => !Cause.hasInterruptsOnly(cause),
-              (cause) => {
-                const requestId = nanoid();
-                return Effect.logError(`${functionAddress} failed during execution.`).pipe(
-                  Effect.annotateLogs({ cause, function: functionAddress, requestId }),
-                  Effect.as({
+              (cause) =>
+                Effect.gen(function* () {
+                  const requestId = yield* ids.generate(RequestId);
+                  yield* Effect.logError(`${functionAddress} failed during execution.`).pipe(
+                    Effect.annotateLogs({ cause, function: functionAddress, requestId }),
+                  );
+                  const result = {
                     type: "Failure" as const,
                     error: { _tag: "InternalServerError", requestId },
-                  }),
-                );
-              },
+                  };
+                  if (kind === "Mutation") {
+                    return { type: "Mutation" as const, result };
+                  }
+                  return {
+                    type: "Query" as const,
+                    result,
+                    dependencies: [],
+                    observedRevision: yield* database.revision,
+                  };
+                }),
             ),
           );
         }),

package/src/dev-runtime/id.ts

@@ -1,11 +1,3 @@
-import { GeneratedId, IdAlphabet, IdLength } from "@ignotum/contracts/runtime/id";
-import { IdGenerator } from "@ignotum/runtime/id";
-import { Effect, Layer } from "effect";
-import { customAlphabet } from "nanoid";
+import { IdGenerator } from "@ignotum/shared/id";
 
-export const idGeneratorLayer = Layer.sync(IdGenerator, () => {
-  const nanoid = customAlphabet(IdAlphabet, IdLength);
-  return IdGenerator.of({
-    generate: Effect.sync(() => GeneratedId.make(nanoid())),
-  });
-});
+export const idGeneratorLayer = IdGenerator.layer;

package/src/dev-runtime/migrations.ts

@@ -0,0 +1,68 @@
+import { Context, Effect, Layer } from "effect";
+import * as Migrator from "effect/unstable/sql/Migrator";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+const initialDevelopmentSchema = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`
+    CREATE TABLE tables (
+      id TEXT PRIMARY KEY NOT NULL
+        CHECK (
+          length(id) = 30
+          AND substr(id, 1, 6) = 'table_'
+          AND substr(id, 7) NOT GLOB '*[^0-9a-z]*'
+        ),
+      name TEXT NOT NULL UNIQUE
+    ) STRICT
+  `;
+  yield* sql`
+    CREATE TABLE documents (
+      id TEXT NOT NULL
+        CHECK (length(id) = 24 AND id NOT GLOB '*[^0-9a-z]*'),
+      tableId TEXT NOT NULL REFERENCES tables(id) ON DELETE RESTRICT,
+      createdAt INTEGER NOT NULL,
+      updatedAt INTEGER NOT NULL,
+      fields TEXT NOT NULL CHECK (json_valid(fields)),
+      PRIMARY KEY (tableId, id)
+    ) STRICT
+  `;
+  yield* sql`
+    CREATE INDEX documents_table_id_idx
+    ON documents (tableId, createdAt, id)
+  `;
+  yield* sql`
+    CREATE TABLE app_state (
+      singleton INTEGER PRIMARY KEY NOT NULL CHECK (singleton = 1),
+      revision INTEGER NOT NULL CHECK (revision >= 0)
+    ) STRICT
+  `;
+  yield* sql`INSERT INTO app_state (singleton, revision) VALUES (1, 0)`;
+  yield* sql`
+    CREATE TABLE invocation_replays (
+      id TEXT PRIMARY KEY NOT NULL,
+      input TEXT NOT NULL,
+      result TEXT NOT NULL CHECK (json_valid(result))
+    ) STRICT
+  `;
+});
+
+export const developmentMigrationLoader = Migrator.fromRecord({
+  "0001_initial_development_schema": initialDevelopmentSchema,
+});
+
+interface DevelopmentDatabaseService {
+  readonly migrated: true;
+}
+
+export class DevelopmentDatabase extends Context.Service<
+  DevelopmentDatabase,
+  DevelopmentDatabaseService
+>()("ignotum/dev-runtime/migrations/DevelopmentDatabase") {
+  static readonly layer = Layer.effect(
+    DevelopmentDatabase,
+    Migrator.make({})({ loader: developmentMigrationLoader, table: "migrations" }).pipe(
+      Effect.orDie,
+      Effect.as(DevelopmentDatabase.of({ migrated: true })),
+    ),
+  );
+}