ignotum 0.0.2 → 0.0.4

package/src/dev-runtime/sync.ts

@@ -3,6 +3,16 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 
 import { NodeHttpServer, NodeServices, NodeSocket } from "@effect/platform-node";
 import { SqliteClient } from "@effect/sql-sqlite-node";
+import {
+  AppId,
+  AppStateRevision,
+  DeploymentGeneration,
+  DeploymentId,
+  InvocationId,
+  RuntimeMutationResult,
+  canonicalInvocationInput,
+  canonicalQueryKey,
+} from "@ignotum/contracts/runtime/hosted";
 import {
   ClientMessageJson,
   ServerMessageJson,
@@ -12,7 +22,6 @@ import {
   type ProtocolErrorCode,
   type ServerMessage,
   type SubscriptionId,
-  type WireResult,
 } from "@ignotum/contracts/runtime/sync";
 import {
   Effect,
@@ -25,44 +34,140 @@ import {
   ManagedRuntime,
   Option,
   Path,
-  PartitionedSemaphore,
   PubSub,
   Ref,
   Schema,
   Semaphore,
 } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { SqlClient, SqlError, SqlSchema } from "effect/unstable/sql";
 import type * as Socket from "effect/unstable/socket/Socket";
 import type { Plugin, ViteDevServer } from "vite";
 import { FunctionRuntime, type PreparedFunction } from "@ignotum/runtime/functions";
-import { QueryInvalidation } from "@ignotum/runtime/sync";
+import {
+  makeDependencyIndex,
+  QueryInvalidation,
+  type QueryInvalidationEvent,
+} from "@ignotum/runtime/sync";
 
 import { generate } from "../cli/codegen.js";
 import { isIgnotumPath, syncPath } from "../internal/http-paths.js";
 import { LocalDatabase } from "./database.js";
 import { idGeneratorLayer } from "./id.js";
+import { DevelopmentDatabase } from "./migrations.js";
 import { FunctionExecutor, FunctionRegistry, functionRuntimeLayer } from "./functions.js";
 
 interface QuerySubscription {
   readonly args: Schema.Json;
   readonly function: FunctionAddress;
+  readonly queryKey: ReturnType<typeof canonicalQueryKey>;
+  refreshGeneration: number;
 }
 
+export const localSyncIdentity = {
+  appId: AppId.make("app_000000000000000000000001"),
+  deploymentId: DeploymentId.make("dep_000000000000000000000001"),
+  generation: DeploymentGeneration.make(0),
+} as const;
+
 export { QueryInvalidation };
 
 export const queryInvalidationLayer = Layer.effect(
   QueryInvalidation,
   Effect.gen(function* () {
-    const pubsub = yield* PubSub.unbounded<void>();
+    const pubsub = yield* PubSub.unbounded<QueryInvalidationEvent>();
+    const latestRevision = yield* Ref.make(AppStateRevision.make(0));
     return QueryInvalidation.of({
-      publish: PubSub.publish(pubsub, undefined),
+      latestRevision: Ref.get(latestRevision),
+      publish: (event) =>
+        Effect.gen(function* () {
+          if (event.type === "Dependencies") {
+            yield* Ref.update(latestRevision, (current) =>
+              AppStateRevision.make(Math.max(current, event.committedRevision)),
+            );
+          }
+          yield* PubSub.publish(pubsub, event);
+        }).pipe(Effect.asVoid),
       subscribe: PubSub.subscribe(pubsub),
     });
   }),
 );
 
-const operationForQuery = (subscriptionId: SubscriptionId): Operation => ({
-  type: "Query",
+class InvocationIdConflict extends Schema.TaggedError<InvocationIdConflict>()(
+  "InvocationIdConflict",
+  {
+    id: Schema.String,
+  },
+) {}
+
+const MutationReplayRow = Schema.Struct({ input: Schema.String, result: Schema.String });
+
+class MutationReplay extends Context.Service<
+  MutationReplay,
+  {
+    readonly execute: (
+      id: InvocationId,
+      input: string,
+      execute: Effect.Effect<RuntimeMutationResult>,
+    ) => Effect.Effect<RuntimeMutationResult, InvocationIdConflict | SqlError.SqlError>;
+  }
+>()("ignotum/dev-runtime/sync/MutationReplay") {
+  static readonly layer = Layer.effect(
+    MutationReplay,
+    Effect.gen(function* () {
+      yield* DevelopmentDatabase;
+      const sql = yield* SqlClient.SqlClient;
+      const findReplay = SqlSchema.findOneOption({
+        Request: Schema.Struct({ id: InvocationId }),
+        Result: MutationReplayRow,
+        execute: ({ id }) => sql`
+          SELECT input, result
+          FROM invocation_replays
+          WHERE id = ${id}
+          LIMIT 1
+        `,
+      });
+
+      return MutationReplay.of({
+        execute: Effect.fn("MutationReplay.execute")(
+          function* (
+            id,
+            input,
+            execute,
+          ): Effect.fn.Return<RuntimeMutationResult, InvocationIdConflict | SqlError.SqlError> {
+            return yield* sql.withTransaction(
+              Effect.gen(function* () {
+                const replay = yield* findReplay({ id }).pipe(
+                  Effect.catchTags({ SchemaError: Effect.die }),
+                );
+                if (Option.isSome(replay)) {
+                  if (replay.value.input !== input) return yield* InvocationIdConflict.make({ id });
+                  return yield* Schema.decodeEffect(Schema.fromJsonString(RuntimeMutationResult))(
+                    replay.value.result,
+                  ).pipe(Effect.orDie);
+                }
+                const result = yield* execute;
+                const encoded = yield* Schema.encodeEffect(
+                  Schema.fromJsonString(RuntimeMutationResult),
+                )(result).pipe(Effect.orDie);
+                yield* sql`
+                INSERT INTO invocation_replays (id, input, result)
+                VALUES (${id}, ${input}, ${encoded})
+              `;
+                return result;
+              }),
+            );
+          },
+        ),
+      });
+    }),
+  );
+}
+
+export const mutationReplayLayer = MutationReplay.layer;
+
+const operationForSubscription = (subscriptionId: SubscriptionId): Operation => ({
+  type: "Subscription",
   id: subscriptionId,
 });
 
@@ -80,9 +185,10 @@ const protocolError = (
 export const runSession = Effect.fn("SyncServer.runSession")(function* (socket: Socket.Socket) {
   const runtime = yield* FunctionRuntime;
   const invalidation = yield* QueryInvalidation;
+  const mutationReplay = yield* MutationReplay;
   const subscriptions = yield* Ref.make(HashMap.empty<SubscriptionId, QuerySubscription>());
+  const dependencyIndex = makeDependencyIndex<SubscriptionId>();
   const invocationFibers = yield* FiberSet.make();
-  const querySemaphore = yield* PartitionedSemaphore.make<SubscriptionId>({ permits: 1 });
   const messageSemaphore = yield* Semaphore.make(1);
   const writeSemaphore = yield* Semaphore.make(1);
   const write = yield* socket.writer;
@@ -128,62 +234,89 @@ export const runSession = Effect.fn("SyncServer.runSession")(function* (socket:
   const executeQuery = Effect.fn("SyncServer.executeQuery")(function* (
     subscriptionId: SubscriptionId,
     subscription: QuerySubscription,
+    refreshGeneration: number,
     previouslyPrepared?: PreparedFunction,
   ) {
-    if (!(yield* isActive(subscriptionId, subscription))) return;
-
-    const operation = operationForQuery(subscriptionId);
+    const operation = operationForSubscription(subscriptionId);
     const deliver = (message: ServerMessage) => sendIfActive(subscriptionId, subscription, message);
-    const prepared =
-      previouslyPrepared ??
-      (yield* runtime.prepare(subscription.function, "Query", subscription.args).pipe(
-        Effect.catchTags({
-          FunctionUnavailable: (error) => sendResolutionError(operation, error, deliver),
-          InvalidArguments: (error) => sendResolutionError(operation, error, deliver),
-          UnknownFunction: (error) => sendResolutionError(operation, error, deliver),
-          WrongFunctionKind: (error) => sendResolutionError(operation, error, deliver),
-        }),
-      ));
-    if (prepared === undefined) return;
-
-    const result = yield* prepared.execute;
-    yield* deliver({
-      type: "QuerySnapshot",
-      id: subscriptionId,
-      result,
-    });
+    let prepared = previouslyPrepared;
+
+    while (yield* isActive(subscriptionId, subscription)) {
+      if (prepared === undefined) {
+        const resolved = yield* runtime
+          .prepare(subscription.function, "Query", subscription.args)
+          .pipe(
+            Effect.catchTags({
+              FunctionUnavailable: (error) => sendResolutionError(operation, error, deliver),
+              InvalidArguments: (error) => sendResolutionError(operation, error, deliver),
+              UnknownFunction: (error) => sendResolutionError(operation, error, deliver),
+              WrongFunctionKind: (error) => sendResolutionError(operation, error, deliver),
+            }),
+          );
+        if (resolved === undefined) return;
+        prepared = resolved;
+      }
+
+      const result = yield* prepared.execute;
+      prepared = undefined;
+      if (result.type !== "Query") return;
+      if (
+        !(yield* isActive(subscriptionId, subscription)) ||
+        subscription.refreshGeneration !== refreshGeneration
+      ) {
+        return;
+      }
+      dependencyIndex.record(subscriptionId, result.dependencies);
+      if ((yield* invalidation.latestRevision) > result.observedRevision) continue;
+      yield* deliver({
+        type: "Snapshot",
+        id: subscriptionId,
+        result: result.result,
+        revision: result.observedRevision,
+      });
+      return;
+    }
   });
 
   const scheduleQuery = (
     subscriptionId: SubscriptionId,
     subscription: QuerySubscription,
     previouslyPrepared?: PreparedFunction,
-  ) =>
-    querySemaphore
-      .withPermits(
-        subscriptionId,
-        1,
-      )(executeQuery(subscriptionId, subscription, previouslyPrepared))
-      .pipe(
-        Effect.catchCause((cause) =>
-          Effect.logError("A query refresh fiber failed.").pipe(
-            Effect.annotateLogs({ cause, function: subscription.function, subscriptionId }),
-          ),
+  ) => {
+    const refreshGeneration = ++subscription.refreshGeneration;
+    return executeQuery(subscriptionId, subscription, refreshGeneration, previouslyPrepared).pipe(
+      Effect.catchCause((cause) =>
+        Effect.logError("A query refresh fiber failed.").pipe(
+          Effect.annotateLogs({ cause, function: subscription.function, subscriptionId }),
         ),
-        FiberSet.run(invocationFibers),
-        Effect.asVoid,
-      );
+      ),
+      FiberSet.run(invocationFibers),
+      Effect.asVoid,
+    );
+  };
 
-  const refresh = Effect.fn("SyncServer.refresh")(function* () {
+  const refreshAll = Effect.fn("SyncServer.refreshAll")(function* () {
     const current = yield* Ref.get(subscriptions);
     yield* Effect.forEach(HashMap.toEntries(current), ([subscriptionId, subscription]) =>
       scheduleQuery(subscriptionId, subscription),
     );
   });
 
+  const refreshAffected = Effect.fn("SyncServer.refreshAffected")(function* (
+    invalidations: Parameters<typeof dependencyIndex.affected>[0],
+  ) {
+    const current = yield* Ref.get(subscriptions);
+    yield* Effect.forEach(dependencyIndex.affected(invalidations), (subscriptionId) => {
+      const subscription = Option.getOrUndefined(HashMap.get(current, subscriptionId));
+      return subscription === undefined ? Effect.void : scheduleQuery(subscriptionId, subscription);
+    });
+  });
+
   const invalidations = yield* invalidation.subscribe;
   yield* PubSub.take(invalidations).pipe(
-    Effect.flatMap(refresh),
+    Effect.flatMap((event) =>
+      event.type === "All" ? refreshAll() : refreshAffected(event.invalidations),
+    ),
     Effect.forever,
     Effect.forkScoped,
   );
@@ -191,7 +324,7 @@ export const runSession = Effect.fn("SyncServer.runSession")(function* (socket:
   const handleSubscribe = Effect.fn("SyncServer.handleSubscribe")(function* (
     message: Extract<ClientMessage, { readonly type: "Subscribe" }>,
   ) {
-    const operation = operationForQuery(message.id);
+    const operation = operationForSubscription(message.id);
     const current = yield* Ref.get(subscriptions);
 
     if (HashMap.has(current, message.id)) {
@@ -218,15 +351,20 @@ export const runSession = Effect.fn("SyncServer.runSession")(function* (socket:
       return;
     }
 
-    const subscription = { args: message.args, function: message.function };
+    const subscription = {
+      args: message.args,
+      function: message.function,
+      queryKey: canonicalQueryKey(localSyncIdentity.deploymentId, message.function, message.args),
+      refreshGeneration: 0,
+    };
     yield* Ref.update(subscriptions, HashMap.set(message.id, subscription));
     yield* scheduleQuery(message.id, subscription, prepared);
   });
 
-  const handleMutate = Effect.fn("SyncServer.handleMutate")(function* (
-    message: Extract<ClientMessage, { readonly type: "Mutate" }>,
+  const handleInvoke = Effect.fn("SyncServer.handleInvoke")(function* (
+    message: Extract<ClientMessage, { readonly type: "Invoke" }>,
   ) {
-    const operation: Operation = { type: "Mutate", id: message.id };
+    const operation: Operation = { type: "Invocation", id: message.id };
     const prepared = yield* runtime.prepare(message.function, "Mutation", message.args).pipe(
       Effect.catchTags({
         FunctionUnavailable: (error) => sendResolutionError(operation, error),
@@ -240,21 +378,61 @@ export const runSession = Effect.fn("SyncServer.runSession")(function* (socket:
       return;
     }
 
-    yield* prepared.execute.pipe(
-      Effect.flatMap((result: WireResult) => {
-        const response = send({ type: "MutationResult", id: message.id, result });
-        return result.type === "Success"
-          ? response.pipe(Effect.ensuring(invalidation.publish))
-          : response;
-      }),
-      Effect.catchCause((cause) =>
-        Effect.logError("A mutation invocation fiber failed.").pipe(
-          Effect.annotateLogs({ cause, function: message.function, requestId: message.id }),
-        ),
-      ),
-      FiberSet.run(invocationFibers),
-      Effect.asVoid,
+    const input = canonicalInvocationInput(
+      localSyncIdentity.deploymentId,
+      "Mutation",
+      message.function,
+      message.args,
     );
+    yield* mutationReplay
+      .execute(
+        message.id,
+        input,
+        prepared.execute.pipe(
+          Effect.flatMap((result) =>
+            result.type === "Mutation" ? Effect.succeed(result) : Effect.die("Expected mutation"),
+          ),
+        ),
+      )
+      .pipe(
+        Effect.flatMap((result) => {
+          if (!("committedRevision" in result)) {
+            return send({ type: "Result", id: message.id, result: result.result });
+          }
+          const response = send({
+            type: "Result",
+            id: message.id,
+            result: result.result,
+            committedRevision: result.committedRevision,
+          });
+          return response.pipe(
+            Effect.ensuring(
+              invalidation.publish({
+                type: "Dependencies",
+                invalidations: result.invalidations,
+                committedRevision: result.committedRevision,
+              }),
+            ),
+          );
+        }),
+        Effect.catchTags({
+          InvocationIdConflict: () =>
+            send(
+              protocolError(
+                "InvocationIdConflict",
+                `Invocation ${message.id} was already used with different inputs.`,
+                operation,
+              ),
+            ),
+        }),
+        Effect.catchCause((cause) =>
+          Effect.logError("A mutation invocation fiber failed.").pipe(
+            Effect.annotateLogs({ cause, function: message.function, requestId: message.id }),
+          ),
+        ),
+        FiberSet.run(invocationFibers),
+        Effect.asVoid,
+      );
   });
 
   const handleMessage = Effect.fn("SyncServer.handleMessage")(function* (text: string) {
@@ -273,15 +451,18 @@ export const runSession = Effect.fn("SyncServer.runSession")(function* (socket:
         yield* handleSubscribe(message);
         return;
       case "Unsubscribe":
+        dependencyIndex.remove(message.id);
         yield* Ref.update(subscriptions, HashMap.remove(message.id));
         return;
-      case "Mutate":
-        yield* handleMutate(message);
+      case "Invoke":
+        yield* handleInvoke(message);
         return;
     }
   });
 
-  yield* socket.runString((text) => messageSemaphore.withPermits(1)(handleMessage(text)));
+  yield* socket.runString((text) => messageSemaphore.withPermits(1)(handleMessage(text)), {
+    onOpen: send({ type: "Handshake", ...localSyncIdentity }).pipe(Effect.orDie),
+  });
 });
 
 interface SyncHandlersService {
@@ -296,19 +477,20 @@ class SyncHandlers extends Context.Service<SyncHandlers, SyncHandlersService>()(
   "ignotum/dev-runtime/sync/SyncHandlers",
 ) {}
 
-const makeHandlersLayer = (
-  server: ViteDevServer,
-  projectDirectory: string,
-  databasePath: string,
-) => {
-  const databaseLayer = LocalDatabase.layer.pipe(
-    Layer.provide(Layer.merge(idGeneratorLayer, SqliteClient.layer({ filename: databasePath }))),
+const makeHandlersLayer = (server: ViteDevServer, appDirectory: string, databasePath: string) => {
+  const sqliteLayer = SqliteClient.layer({ filename: databasePath });
+  const persistenceLayer = Layer.merge(LocalDatabase.layer, mutationReplayLayer).pipe(
+    Layer.provideMerge(DevelopmentDatabase.layer),
+    Layer.provide(Layer.merge(idGeneratorLayer, sqliteLayer)),
+  );
+  const executorLayer = FunctionExecutor.layer.pipe(
+    Layer.provide(persistenceLayer),
+    Layer.provide(idGeneratorLayer),
   );
-  const executorLayer = FunctionExecutor.layer.pipe(Layer.provide(databaseLayer));
   const devFunctionRuntimeLayer = functionRuntimeLayer.pipe(
     Layer.provide(
       Layer.merge(
-        FunctionRegistry.layer(server, projectDirectory).pipe(Layer.provide(NodeServices.layer)),
+        FunctionRegistry.layer(server, appDirectory).pipe(Layer.provide(NodeServices.layer)),
         executorLayer,
       ),
     ),
@@ -316,6 +498,7 @@ const makeHandlersLayer = (
   const dependencies = Layer.mergeAll(
     devFunctionRuntimeLayer,
     queryInvalidationLayer,
+    persistenceLayer,
     NodeServices.layer,
   );
 
@@ -358,7 +541,7 @@ const makeHandlersLayer = (
         socketApp,
         { scope },
       );
-      const serverDirectory = path.join(projectDirectory, "server");
+      const serverDirectory = path.join(appDirectory, "server");
       const reloadUnsafe = Effect.fn("SyncServer.reload")(function* (
         file: string,
         event: "add" | "change" | "unlink",
@@ -369,12 +552,12 @@ const makeHandlersLayer = (
         }
 
         if (event !== "change") {
-          yield* generate(projectDirectory).pipe(
+          yield* generate(appDirectory).pipe(
             Effect.provideService(FileSystem.FileSystem, fileSystem),
             Effect.provideService(Path.Path, path),
           );
         }
-        yield* invalidation.publish;
+        yield* invalidation.publish({ type: "All" });
       });
       const reload = (file: string, event: "add" | "change" | "unlink") =>
         reloadSemaphore
@@ -415,16 +598,16 @@ const rejectUpgrade = (socket: import("node:stream").Duplex): void => {
 export const syncPluginInternals = { isAppOrigin };
 
 export const ignotumSyncPlugin: {
-  (databasePath: string): (projectDirectory: string) => Plugin;
-  (projectDirectory: string, databasePath: string): Plugin;
-} = Function.dual(2, (projectDirectory: string, databasePath: string): Plugin => ({
+  (databasePath: string): (appDirectory: string) => Plugin;
+  (appDirectory: string, databasePath: string): Plugin;
+} = Function.dual(2, (appDirectory: string, databasePath: string): Plugin => ({
   name: "ignotum:sync",
   configureServer: (server) => {
     if (server.httpServer === null) {
       throw new Error("Ignotum sync requires Vite's Node HTTP server.");
     }
 
-    const runtime = ManagedRuntime.make(makeHandlersLayer(server, projectDirectory, databasePath));
+    const runtime = ManagedRuntime.make(makeHandlersLayer(server, appDirectory, databasePath));
     const httpServer = server.httpServer;
     return runtime.runPromise(SyncHandlers).then(
       (handlers) => {

package/src/internal/function-definition.ts

@@ -0,0 +1,77 @@
+import {
+  getFunctionSchema,
+  type FunctionSchemaCarrier,
+  type RuntimeSchemaDefinition,
+} from "@ignotum/contracts/runtime/schema";
+import type { ErrorValue } from "@ignotum/contracts/runtime/result";
+import type { FunctionKind } from "@ignotum/contracts/runtime/functions";
+import type { TransportValue } from "@ignotum/contracts/runtime/sync";
+import { Predicate, Schema } from "effect";
+import type { Effect } from "effect";
+
+type RuntimeFields = Readonly<Record<string, Schema.ConstraintDecoder<unknown>>>;
+
+declare const FunctionArgumentsTypeId: unique symbol;
+export interface FunctionArguments {
+  readonly [FunctionArgumentsTypeId]?: never;
+}
+
+export interface RuntimeFunctionDefinition<Context = unknown> {
+  readonly _tag: FunctionKind;
+  readonly args?: RuntimeFields;
+  readonly returns?: Schema.Codec<unknown, unknown>;
+  readonly errors?: Schema.Codec<unknown, unknown>;
+  readonly handler: (
+    context: Context,
+    args: FunctionArguments,
+  ) => Generator<Effect.Effect<unknown, ErrorValue, never>, TransportValue | void, never>;
+}
+
+export interface InspectedRuntimeFunctionDefinition<Context = unknown> {
+  readonly definition: RuntimeFunctionDefinition<Context>;
+  readonly schema: RuntimeSchemaDefinition;
+}
+
+interface RuntimeFunctionCandidate extends FunctionSchemaCarrier {
+  readonly _tag?: unknown;
+  readonly args?: unknown;
+  readonly returns?: unknown;
+  readonly errors?: unknown;
+  readonly handler?: unknown;
+}
+
+export const inspectRuntimeFunctionDefinition = <Context = unknown>(
+  value: RuntimeFunctionCandidate,
+): InspectedRuntimeFunctionDefinition<Context> | 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<Context>, schema };
+};

package/src/internal/host.ts

@@ -0,0 +1 @@
+export { invoke } from "@ignotum/runtime/guest";

package/src/internal/http-paths.ts

@@ -1,5 +1,7 @@
+import { appSyncPath } from "@ignotum/contracts/runtime/transport";
+
 export const ignotumPathPrefix = "/_ignotum";
-export const syncPath = `${ignotumPathPrefix}/sync`;
+export const syncPath = appSyncPath;
 
 export const isIgnotumPath = (pathname: string): boolean =>
   pathname === ignotumPathPrefix || pathname.startsWith(`${ignotumPathPrefix}/`);

package/dist/runtime/api-BXXIZc_Q.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-BXXIZc_Q.js","names":[],"sources":["../../../contracts/dist/runtime/sync.js","../../src/internal/api.ts"],"sourcesContent":["import { a as decodeTransportValue, i as decodeTransportObject, n as datePathsOf, o as encodeTransportObject, r as datePathsOfObject, s as encodeTransportValue, t as TransportValueSchema } from \"../value-Briqf-Ua.js\";\nimport { Schema } from \"effect\";\n//#region src/runtime/sync.ts\nconst FunctionNamePart = Schema.String.check(Schema.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]*$/));\nconst ApiFunctionAddressParts = Schema.TemplateLiteralParser([\n\t\"api.\",\n\tFunctionNamePart,\n\t\".\",\n\tFunctionNamePart\n]);\nconst FunctionAddress = Schema.TemplateLiteral([\n\t\"api.\",\n\tFunctionNamePart,\n\t\".\",\n\tFunctionNamePart\n]);\nconst apiFunctionParts = (address) => {\n\tconst [, moduleName, , functionName] = Schema.decodeSync(ApiFunctionAddressParts)(address);\n\treturn {\n\t\tfunctionName,\n\t\tmoduleName\n\t};\n};\nconst SubscriptionId = Schema.Natural.pipe(Schema.brand(\"ignotum/sync/SubscriptionId\"));\nconst RequestId = Schema.Natural.pipe(Schema.brand(\"ignotum/sync/RequestId\"));\nconst Subscribe = Schema.Struct({\n\ttype: Schema.Literal(\"Subscribe\"),\n\tid: SubscriptionId,\n\tfunction: FunctionAddress,\n\targs: Schema.Json\n});\nconst Unsubscribe = Schema.Struct({\n\ttype: Schema.Literal(\"Unsubscribe\"),\n\tid: SubscriptionId\n});\nconst Mutate = Schema.Struct({\n\ttype: Schema.Literal(\"Mutate\"),\n\tid: RequestId,\n\tfunction: FunctionAddress,\n\targs: Schema.Json\n});\nconst ClientMessage = Schema.Union([\n\tSubscribe,\n\tUnsubscribe,\n\tMutate\n]);\nconst QueryOperation = Schema.Struct({\n\ttype: Schema.Literal(\"Query\"),\n\tid: SubscriptionId\n});\nconst MutateOperation = Schema.Struct({\n\ttype: Schema.Literal(\"Mutate\"),\n\tid: RequestId\n});\nconst Operation = Schema.Union([QueryOperation, MutateOperation]);\nconst DatePath = Schema.Array(Schema.Union([Schema.String, Schema.Natural]));\nconst DatePaths = Schema.Array(DatePath);\nconst WireResult = Schema.Union([Schema.Struct({\n\ttype: Schema.Literal(\"Success\"),\n\tvalue: Schema.optional(Schema.Json),\n\tdates: Schema.optional(DatePaths)\n}), Schema.Struct({\n\ttype: Schema.Literal(\"Failure\"),\n\terror: Schema.Json,\n\tdates: Schema.optional(DatePaths)\n})]);\nconst QuerySnapshot = Schema.Struct({\n\ttype: Schema.Literal(\"QuerySnapshot\"),\n\tid: SubscriptionId,\n\tresult: WireResult\n});\nconst MutationResult = Schema.Struct({\n\ttype: Schema.Literal(\"MutationResult\"),\n\tid: RequestId,\n\tresult: WireResult\n});\nconst ProtocolErrorCode = Schema.Literals([\n\t\"DuplicateOperationId\",\n\t\"FunctionUnavailable\",\n\t\"InvalidArguments\",\n\t\"InvalidMessage\",\n\t\"UnknownFunction\",\n\t\"WrongFunctionKind\"\n]);\nconst ProtocolError = Schema.Struct({\n\ttype: Schema.Literal(\"ProtocolError\"),\n\toperation: Schema.optional(Operation),\n\tcode: ProtocolErrorCode,\n\tmessage: Schema.String\n});\nconst ServerMessage = Schema.Union([\n\tQuerySnapshot,\n\tMutationResult,\n\tProtocolError\n]);\nconst ClientMessageJson = Schema.fromJsonString(ClientMessage);\nconst ServerMessageJson = Schema.fromJsonString(ServerMessage);\n//#endregion\nexport { ClientMessage, ClientMessageJson, DatePath, FunctionAddress, FunctionNamePart, Operation, ProtocolErrorCode, RequestId, ServerMessage, ServerMessageJson, SubscriptionId, TransportValueSchema, WireResult, apiFunctionParts, datePathsOf, datePathsOfObject, decodeTransportObject, decodeTransportValue, encodeTransportObject, encodeTransportValue };\n\n//# sourceMappingURL=sync.js.map","import { Predicate } from \"effect\";\nimport type { Effect } from \"effect\";\n\nimport type { ErrorValue, InternalServerError } from \"@ignotum/contracts/runtime/result\";\nimport { FunctionAddress } from \"@ignotum/contracts/runtime/sync\";\n\nconst FunctionReferenceTypeId: unique symbol = Symbol.for(\"ignotum/internal/api/FunctionReference\");\ndeclare const FunctionReferenceTypesTypeId: unique symbol;\n\ntype FunctionKind = \"Mutation\" | \"Query\";\n\nexport interface FunctionReference<\n  Kind extends FunctionKind,\n  Args,\n  Success,\n  Failure extends ErrorValue,\n> {\n  readonly [FunctionReferenceTypeId]: FunctionAddress;\n  readonly [FunctionReferenceTypesTypeId]?: {\n    readonly kind: Kind;\n    readonly args: Args;\n    readonly value: Success;\n    readonly error: Failure;\n  };\n}\n\ntype ReferenceTypes<Reference> = Reference extends {\n  readonly [FunctionReferenceTypesTypeId]?: infer Types;\n}\n  ? Exclude<Types, undefined>\n  : never;\n\nexport declare namespace FunctionReference {\n  type Args<Reference> =\n    ReferenceTypes<Reference> extends { readonly args: infer Args } ? Args : never;\n  type Failure<Reference> =\n    ReferenceTypes<Reference> extends {\n      readonly error: infer Failure;\n    }\n      ? Failure\n      : never;\n  type Kind<Reference> =\n    ReferenceTypes<Reference> extends { readonly kind: infer Kind } ? Kind : never;\n  type Success<Reference> =\n    ReferenceTypes<Reference> extends {\n      readonly value: infer Success;\n    }\n      ? Success\n      : never;\n}\n\ntype ReferenceOf<Definition> = Definition extends {\n  readonly _tag: infer Kind extends FunctionKind;\n  readonly handler: (\n    ...arguments_: infer HandlerArguments\n  ) => Generator<infer Yielded, infer Success, never>;\n}\n  ? HandlerArguments extends readonly [infer _Context, ...infer Rest]\n    ? FunctionReference<\n        Kind,\n        Rest extends readonly [infer Args, ...ReadonlyArray<unknown>] ? Args : void,\n        Success,\n        | (Yielded extends Effect.Effect<unknown, infer Failure extends ErrorValue, never>\n            ? Failure\n            : never)\n        | InternalServerError\n      >\n    : never\n  : never;\n\ntype ApiModule<Module> = {\n  readonly [FunctionName in keyof Module as FunctionName extends string\n    ? ReferenceOf<Module[FunctionName]> extends never\n      ? never\n      : FunctionName\n    : never]: ReferenceOf<Module[FunctionName]>;\n};\n\nexport type Api<Modules> = {\n  readonly [ModuleName in keyof Modules]: ApiModule<Modules[ModuleName]>;\n};\n\nexport const functionPathOf = <\n  Kind extends FunctionKind,\n  Args,\n  Success,\n  Failure extends ErrorValue,\n>(\n  reference: FunctionReference<Kind, Args, Success, Failure>,\n) => reference[FunctionReferenceTypeId];\n\nconst makeModuleReference = (moduleName: string) => {\n  const references = new Map<string, object>();\n\n  return new Proxy(\n    {},\n    {\n      get: (_target, functionName) => {\n        if (!Predicate.isString(functionName)) {\n          return undefined;\n        }\n\n        const existing = references.get(functionName);\n        if (existing !== undefined) {\n          return existing;\n        }\n\n        const reference = {\n          [FunctionReferenceTypeId]: FunctionAddress.make(`api.${moduleName}.${functionName}`),\n        };\n        references.set(functionName, reference);\n        return reference;\n      },\n    },\n  );\n};\n\nexport function createApi<Modules>(): Api<Modules>;\nexport function createApi() {\n  const modules = new Map<string, object>();\n\n  return new Proxy(\n    {},\n    {\n      get: (_target, moduleName) => {\n        if (!Predicate.isString(moduleName)) {\n          return undefined;\n        }\n\n        const existing = modules.get(moduleName);\n        if (existing !== undefined) {\n          return existing;\n        }\n\n        const moduleReference = makeModuleReference(moduleName);\n        modules.set(moduleName, moduleReference);\n        return moduleReference;\n      },\n    },\n  );\n}\n"],"mappings":"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"}

package/dist/runtime/result-B2W-z2wG.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"result-B2W-z2wG.js","names":[],"sources":["../../../contracts/dist/value-Briqf-Ua.js","../../../contracts/dist/runtime/result.js"],"sourcesContent":["import { Predicate, Schema } from \"effect\";\n//#region src/runtime/value.ts\nconst TransportValueSchema = Schema.suspend(() => Schema.Union([\n\tSchema.Null,\n\tSchema.Boolean,\n\tSchema.Finite,\n\tSchema.String,\n\tSchema.Date,\n\tSchema.Array(TransportValueSchema),\n\tSchema.Record(Schema.String, Schema.UndefinedOr(TransportValueSchema))\n]));\nconst encodeTransportValue = (value) => {\n\tif (Predicate.isDate(value)) return Schema.encodeSync(Schema.DateFromMillis)(value);\n\tif (globalThis.Array.isArray(value)) return value.map(encodeTransportValue);\n\tif (Predicate.isNumber(value)) return Schema.decodeSync(Schema.Finite)(value);\n\tif (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isBoolean(value)) return value;\n\treturn Object.fromEntries(Object.entries(value).flatMap(([key, child]) => child === void 0 ? [] : [[key, encodeTransportValue(child)]]));\n};\nconst encodeTransportObject = (value) => Schema.decodeUnknownSync(Schema.JsonObject)(encodeTransportValue(Schema.decodeUnknownSync(TransportValueSchema)(value)));\nconst collectDatePaths = (value, path, paths) => {\n\tif (Predicate.isDate(value)) {\n\t\tSchema.decodeSync(Schema.Date)(value);\n\t\tpaths.push(path);\n\t\treturn;\n\t}\n\tif (globalThis.Array.isArray(value)) {\n\t\tfor (const [index, child] of value.entries()) collectDatePaths(child, [...path, index], paths);\n\t\treturn;\n\t}\n\tif (value === void 0 || Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return;\n\tfor (const [key, child] of Object.entries(value)) collectDatePaths(child, [...path, key], paths);\n};\nconst datePathsOf = (value) => {\n\tconst paths = [];\n\tcollectDatePaths(value, [], paths);\n\treturn paths;\n};\nconst datePathsOfObject = (value) => datePathsOf(Schema.decodeUnknownSync(TransportValueSchema)(value));\nconst pathKey = (path) => JSON.stringify(path);\nconst decodeTransportValueAt = (value, path, encodedDatePaths) => {\n\tif (encodedDatePaths.has(pathKey(path))) return Schema.decodeUnknownSync(Schema.DateFromMillis)(value);\n\tif (globalThis.Array.isArray(value)) return value.map((item, index) => decodeTransportValueAt(item, [...path, index], encodedDatePaths));\n\tif (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return value;\n\treturn Object.fromEntries(Object.entries(value).map(([key, item]) => [key, decodeTransportValueAt(item, [...path, key], encodedDatePaths)]));\n};\nconst decodeTransportValue = (value, datePaths) => decodeTransportValueAt(value, [], new Set(datePaths.map(pathKey)));\nconst decodeTransportObject = (value, datePaths) => {\n\tconst encodedDatePaths = new Set(datePaths.map(pathKey));\n\treturn Object.fromEntries(Object.entries(value).map(([key, child]) => [key, decodeTransportValueAt(child, [key], encodedDatePaths)]));\n};\n//#endregion\nexport { decodeTransportValue as a, decodeTransportObject as i, datePathsOf as n, encodeTransportObject as o, datePathsOfObject as r, encodeTransportValue as s, TransportValueSchema as t };\n\n//# sourceMappingURL=value-Briqf-Ua.js.map","import { i as decodeTransportObject } from \"../value-Briqf-Ua.js\";\nimport { Brand, Effect, Effectable, Function, Option, Predicate, Schema } from \"effect\";\n//#region src/runtime/result.ts\nconst ResultTypeId = Symbol.for(\"ignotum/runtime/result/Result\");\nconst CompletedResultTypeId = Symbol.for(\"ignotum/runtime/result/Completed\");\nconst PendingResultTypeId = Symbol.for(\"ignotum/runtime/result/Pending\");\nconst ErrorBrand = \"ignotum/error\";\nconst makeErrorValue = Brand.nominal();\nconst ErrorValueSchema = Schema.StructWithRest(Schema.Struct({ _tag: Schema.String }), [Schema.Record(Schema.String, Schema.Json)]).pipe(Schema.brand(ErrorBrand));\nvar InternalServerErrorCause = class extends Schema.TaggedError()(\"InternalServerError\", { requestId: Schema.String }) {};\nconst InternalServerError = InternalServerErrorCause;\nconst InternalServerErrorSchema = InternalServerErrorCause.pipe(Schema.brand(ErrorBrand));\nconst effectOf = (value) => Predicate.hasProperty(value, ResultTypeId) ? value[ResultTypeId] : Effect.succeed(value);\nfunction makeResultEffectBase() {\n\tconst Base = function() {};\n\tBase.prototype = Effectable.Prototype({\n\t\tlabel: \"IgnotumResult\",\n\t\tevaluate() {\n\t\t\treturn this[ResultTypeId];\n\t\t}\n\t});\n\treturn Base;\n}\nconst ResultEffectBase = makeResultEffectBase();\nvar ResultOperation = class ResultOperation extends ResultEffectBase {\n\t[ResultTypeId];\n\tconstructor(effect, completed) {\n\t\tsuper();\n\t\tthis[ResultTypeId] = effect;\n\t\tif (completed !== void 0) Object.defineProperty(this, CompletedResultTypeId, { value: completed });\n\t}\n\tcatch(cases) {\n\t\tconst effectCases = {};\n\t\tfor (const [tag, handler] of Object.entries(cases)) if (Predicate.isFunction(handler)) effectCases[tag] = (failure) => effectOf(handler(failure));\n\t\tconst runtimeEffect = this[ResultTypeId];\n\t\tconst caught = Effect.catchTags(runtimeEffect, effectCases);\n\t\treturn new ResultOperation(caught);\n\t}\n};\nvar PendingQueryResult = class {\n\t[PendingResultTypeId] = PendingResultTypeId;\n};\nconst inspectResult = (value) => {\n\tif (!Predicate.hasProperty(value, CompletedResultTypeId)) return void 0;\n\treturn value[CompletedResultTypeId];\n};\nconst effectFromResult = (result) => result[ResultTypeId];\nconst resultFromEffect = (effect) => new ResultOperation(effect);\nconst isFailureResult = (result) => Predicate.hasProperty(result, CompletedResultTypeId) && Predicate.isObject(result[CompletedResultTypeId]) && Predicate.hasProperty(result[CompletedResultTypeId], \"type\") && result[CompletedResultTypeId].type === \"Failure\";\nconst succeed = (value) => new ResultOperation(Effect.succeed(value), {\n\ttype: \"Success\",\n\tvalue\n});\nconst fail = (error) => new ResultOperation(Effect.fail(error), {\n\ttype: \"Failure\",\n\terror\n});\nconst tryResult = (body) => {\n\treturn new ResultOperation(Effect.gen(body));\n};\nconst match = Function.dual(2, (result, matchers) => {\n\tif (result instanceof PendingQueryResult) {\n\t\tif (matchers.pending === void 0) throw new Error(\"A pending Result requires a pending matcher.\");\n\t\treturn matchers.pending();\n\t}\n\tif (!Predicate.hasProperty(result, ResultTypeId)) throw new Error(\"Unknown Result implementation.\");\n\tconst inspected = inspectResult(result);\n\tif (inspected?.type === \"Success\") {\n\t\tconst value = inspected.value;\n\t\treturn matchers.value(value);\n\t}\n\tif (!isFailureResult(result)) throw new Error(\"Unknown or incomplete Result operation.\");\n\tconst error = result[CompletedResultTypeId].error;\n\tif (error._tag === \"InternalServerError\") {\n\t\tconst internalError = Schema.decodeUnknownSync(InternalServerErrorSchema)(error);\n\t\tconst handler = matchers.internalError;\n\t\tif (handler === void 0) throw internalError;\n\t\treturn handler(internalError);\n\t}\n\tconst errorMatcher = matchers.error;\n\tif (errorMatcher === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);\n\tif (Predicate.isFunction(errorMatcher)) return errorMatcher(error);\n\tconst handlers = errorMatcher;\n\tconst handler = Object.hasOwn(handlers, error._tag) ? handlers[error._tag] : void 0;\n\tif (handler === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);\n\treturn handler(error);\n});\nconst pending = () => new PendingQueryResult();\nconst failureFromWire = (error, datePaths = []) => {\n\tconst internalError = Schema.decodeUnknownOption(InternalServerErrorSchema)(error);\n\tif (Option.isSome(internalError)) return fail(internalError.value);\n\tconst decoded = Schema.decodeUnknownOption(ErrorValueSchema)(error);\n\tif (Option.isNone(decoded)) throw new Error(\"The server returned an invalid application error.\");\n\tconst restored = decodeTransportObject(decoded.value, datePaths);\n\treturn fail(makeErrorValue({\n\t\t...restored,\n\t\t_tag: decoded.value._tag\n\t}));\n};\nconst documentNotFound = (table, id) => Brand.nominal()({\n\t_tag: \"DocumentNotFound\",\n\ttable,\n\tid\n});\nconst Result = {\n\tfail,\n\tmatch,\n\tsucceed,\n\ttry: tryResult\n};\n//#endregion\nexport { ErrorBrand, ErrorValueSchema, InternalServerError, InternalServerErrorSchema, Result, documentNotFound, effectFromResult, failureFromWire, inspectResult, match, pending, resultFromEffect };\n\n//# sourceMappingURL=result.js.map"],"mappings":"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"}