ignotum 0.0.0 → 0.0.2

package/src/dev-runtime/functions.ts

@@ -0,0 +1,293 @@
+import {
+  FunctionUnavailable,
+  InvalidArguments,
+  UnknownFunction,
+  WrongFunctionKind,
+  type FunctionKind,
+  type FunctionResolutionError,
+} from "@ignotum/contracts/runtime/functions";
+import {
+  getFunctionSchema,
+  type FunctionSchemaCarrier,
+  type RuntimeSchemaDefinition,
+} from "@ignotum/contracts/runtime/schema";
+import { ErrorValueSchema, type ErrorValue } from "@ignotum/contracts/runtime/result";
+import {
+  FunctionAddress,
+  apiFunctionParts,
+  datePathsOf,
+  datePathsOfObject,
+  type TransportValue,
+  type WireResult,
+} 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";
+
+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 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 interface ResolvedFunction {
+  readonly definition: RuntimeFunctionDefinition;
+  readonly args: FunctionArguments;
+  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,
+  {
+    readonly resolve: (
+      functionAddress: FunctionAddress,
+      kind: FunctionKind,
+      args: Schema.Json,
+    ) => Effect.Effect<ResolvedFunction, FunctionResolutionError>;
+  }
+>()("ignotum/dev-runtime/functions/FunctionRegistry") {
+  static layer(server: ViteDevServer, projectDirectory: string) {
+    return Layer.effect(
+      FunctionRegistry,
+      Effect.gen(function* () {
+        const path = yield* Path.Path;
+        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 loadedModule = yield* Effect.tryPromise({
+              try: () => server.ssrLoadModule(modulePath),
+              catch: (cause) =>
+                FunctionUnavailable.make({
+                  cause,
+                  function: functionAddress,
+                  message: `Could not load ${functionAddress}.`,
+                }),
+            });
+            const candidate = loadedModule[functionName];
+
+            const inspected = Predicate.isObject(candidate)
+              ? inspectRuntimeFunctionDefinition(candidate)
+              : undefined;
+            if (inspected === undefined) {
+              return yield* UnknownFunction.make({
+                function: functionAddress,
+                message: `Unknown server function ${functionAddress}.`,
+              });
+            }
+            const definition = inspected.definition;
+
+            if (definition._tag !== kind) {
+              return yield* WrongFunctionKind.make({
+                actual: definition._tag,
+                expected: kind,
+                function: functionAddress,
+                message: `${functionAddress} is a ${definition._tag.toLowerCase()}, not a ${kind.toLowerCase()}.`,
+              });
+            }
+
+            const decodedArgs = yield* Schema.decodeEffect(
+              Schema.toCodecJson(Schema.Struct(definition.args ?? {})),
+            )(args).pipe(
+              Effect.mapError(() =>
+                InvalidArguments.make({
+                  function: functionAddress,
+                  message: `Invalid arguments for ${functionAddress}.`,
+                }),
+              ),
+            );
+
+            return { args: decodedArgs, definition, schema: inspected.schema };
+          }),
+        });
+      }),
+    );
+  }
+}
+
+class MutationApplicationFailure extends Schema.TaggedError<MutationApplicationFailure>()(
+  "MutationApplicationFailure",
+  { error: Schema.Json },
+) {}
+
+export class FunctionExecutor extends Context.Service<
+  FunctionExecutor,
+  {
+    readonly execute: (
+      functionAddress: FunctionAddress,
+      kind: FunctionKind,
+      resolved: ResolvedFunction,
+    ) => Effect.Effect<WireResult>;
+  }
+>()("ignotum/dev-runtime/functions/FunctionExecutor") {
+  static readonly layer = Layer.effect(
+    FunctionExecutor,
+    Effect.gen(function* () {
+      const database = yield* LocalDatabase;
+      const mutationSemaphore = yield* Semaphore.make(1);
+
+      const encodeSuccess = (
+        definition: RuntimeFunctionDefinition,
+        value: TransportValue | void,
+      ) =>
+        definition.returns === undefined
+          ? Schema.encodeUnknownEffect(Schema.Undefined)(value).pipe(
+              Effect.orDie,
+              Effect.as<WireResult>({ type: "Success" }),
+            )
+          : Schema.encodeEffect(Schema.toCodecJson(definition.returns))(value).pipe(
+              Effect.orDie,
+              Effect.map((encoded): WireResult => {
+                const result: WireResult = { type: "Success", value: encoded };
+                const dates = datePathsOf(value);
+                return dates.length === 0 ? result : { ...result, dates };
+              }),
+            );
+
+      const encodeFailure = (definition: RuntimeFunctionDefinition, error: ErrorValue) =>
+        Schema.encodeEffect(Schema.toCodecJson(definition.errors ?? ErrorValueSchema))(error).pipe(
+          Effect.orDie,
+          Effect.map((encoded): WireResult => {
+            const result: WireResult = { type: "Failure", error: encoded };
+            const dates = datePathsOfObject(error);
+            return dates.length === 0 ? result : { ...result, dates };
+          }),
+        );
+
+      return FunctionExecutor.of({
+        execute: Effect.fn("FunctionExecutor.execute")(function* (functionAddress, kind, resolved) {
+          const invoke = (context: RuntimeHandlerContext) =>
+            Effect.gen(() => resolved.definition.handler(context, resolved.args)).pipe(
+              Effect.matchEffect({
+                onFailure: (error) => encodeFailure(resolved.definition, error),
+                onSuccess: (value) => encodeSuccess(resolved.definition, value),
+              }),
+            );
+
+          const execution =
+            kind === "Query"
+              ? database.queryTransaction(resolved.schema, invoke)
+              : mutationSemaphore.withPermits(1)(
+                  database
+                    .mutationTransaction(resolved.schema, (context) =>
+                      invoke(context).pipe(
+                        Effect.flatMap((result) =>
+                          result.type === "Failure"
+                            ? Effect.fail(MutationApplicationFailure.make({ error: result.error }))
+                            : Effect.succeed(result),
+                        ),
+                      ),
+                    )
+                    .pipe(
+                      Effect.catchTags({
+                        MutationApplicationFailure: ({ error }) =>
+                          Effect.succeed({ type: "Failure" as const, error }),
+                      }),
+                    ),
+                );
+
+          return yield* execution.pipe(
+            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({
+                    type: "Failure" as const,
+                    error: { _tag: "InternalServerError", requestId },
+                  }),
+                );
+              },
+            ),
+          );
+        }),
+      });
+    }),
+  );
+}
+
+/** Adapts the Vite/SQLite development implementation to the shared runtime contract. */
+export const functionRuntimeLayer = Layer.effect(
+  FunctionRuntime,
+  Effect.gen(function* () {
+    const registry = yield* FunctionRegistry;
+    const executor = yield* FunctionExecutor;
+    return FunctionRuntime.of({
+      prepare: Effect.fn("DevFunctionRuntime.prepare")(function* (functionAddress, kind, args) {
+        const resolved = yield* registry.resolve(functionAddress, kind, args);
+        return { execute: executor.execute(functionAddress, kind, resolved) };
+      }),
+    });
+  }),
+);

package/src/dev-runtime/id.ts

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