ignotum 0.0.12 → 0.0.14

package/src/cli/build/server.ts

@@ -513,16 +513,28 @@ const discoverServerFunctions = Effect.fn("Deploy.discoverServerFunctionsIsolate
   );
 });
 
-const serverFunctionEntryPlugin = (definition: DiscoveredServerFunction): Plugin => {
+const serverFunctionEntryPlugin = (
+  definition: DiscoveredServerFunction,
+  schemaPath?: string,
+): Plugin => {
   const entryId = `virtual:ignotum/server-function/${definition.address}`;
   const resolvedEntryId = `\0${entryId}`;
-  const source = `import { call } from ${encodeJavaScriptString(hostModuleId)}
+  const source =
+    schemaPath === undefined
+      ? `import { call } from ${encodeJavaScriptString(hostModuleId)}
 import { invoke } from "ignotum/internal/host"
 import { ${definition.exportName} as definition } from ${encodeJavaScriptString(normalizePath(definition.modulePath))}
 
 export default async function handler(encodedRequest, encodedEnvironment) {
   return invoke(definition, JSON.parse(encodedRequest), call, JSON.parse(encodedEnvironment))
 }
+`
+      : `import { evolve } from "ignotum/internal/host"
+import schema from ${encodeJavaScriptString(normalizePath(schemaPath))}
+
+export default function handler(encodedRequest) {
+  return evolve(schema, encodedRequest)
+}
 `;
 
   return {
@@ -537,6 +549,7 @@ const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
   serverOutputDirectory: string,
   conditions: ReadonlyArray<string>,
   definition: DiscoveredServerFunction,
+  schemaPath?: string,
 ) {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
@@ -573,7 +586,7 @@ const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
     configFile: false,
     logLevel: "warn",
     mode: "production",
-    plugins: [boundaries, serverFunctionEntryPlugin(definition)],
+    plugins: [boundaries, serverFunctionEntryPlugin(definition, schemaPath)],
     publicDir: false,
     resolve: {
       conditions: [...conditions],
@@ -599,8 +612,9 @@ const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
   }
   if (
     entry.dynamicImports.length > 0 ||
-    entry.imports.length !== 1 ||
-    entry.imports[0] !== hostModuleId ||
+    (schemaPath === undefined
+      ? entry.imports.length !== 1 || entry.imports[0] !== hostModuleId
+      : entry.imports.length !== 0) ||
     !entry.exports.includes("default")
   ) {
     return yield* InvalidBuildOutput.make({
@@ -667,8 +681,23 @@ export const buildServer = Effect.fn("Deploy.buildServer")(function* (
     (definition) => buildServerFunction(appDirectory, outputDirectory, conditions, definition),
     { concurrency: 4 },
   );
+  const schemaPath = path.join(appDirectory, "server", "schema.ts");
+  const schemaEvolution = yield* buildServerFunction(
+    appDirectory,
+    outputDirectory,
+    conditions,
+    {
+      address: FunctionAddress.make("api._schema.evolve"),
+      exportName: "evolve",
+      kind: "Mutation",
+      moduleName: "_schema",
+      modulePath: schemaPath,
+    },
+    schemaPath,
+  );
   const manifest = {
-    formatVersion: 3,
+    formatVersion: 4,
+    schemaEvolution: { bundle: schemaEvolution.bundle, sourceMap: schemaEvolution.sourceMap },
     environment: {
       artifact: yield* artifactReference(serverEnvironmentPath, environmentBytes),
       fields: discovered.environment.fields,

package/src/cli/command.ts

@@ -13,7 +13,8 @@ import {
   status as readAuthStatus,
 } from "./auth-client.js";
 import { ControlClient } from "./control-client.js";
-import { deploy as runDeploy } from "./deploy.js";
+import { deploy as runDeploy, resumeDeployment } from "./deploy.js";
+import { DeploymentId } from "@ignotum/contracts/runtime/identity";
 import { resetDevDatabase } from "../dev-runtime/dev-database.js";
 import { dev as runDev } from "./dev.js";
 import { createApp } from "./new-app.js";
@@ -144,15 +145,37 @@ const dev = Command.make(
 const deploy = Command.make(
   "deploy",
   {
+    resume: Flag.string("resume").pipe(
+      Flag.withDescription("Finish activation of an already uploaded deployment."),
+      Flag.withSchema(DeploymentId),
+      Flag.optional,
+    ),
     app: Flag.string("app").pipe(
       Flag.withDescription("Create or link this app slug on the first deploy."),
       Flag.withSchema(AppSlug),
       Flag.optional,
     ),
   },
-  Effect.fn("deploy")(function* ({ app }) {
+  Effect.fn("deploy")(function* ({ app, resume }) {
     const path = yield* Path.Path;
     const terminal = yield* Terminal.Terminal;
+    if (Option.isSome(resume)) {
+      const result = yield* resumeDeployment(
+        path.resolve("."),
+        resume.value,
+        Option.getOrUndefined(app),
+      ).pipe(
+        // @effect-diagnostics-next-line strictEffectProvide:off This command owns the authenticated control client.
+        Effect.provide(ControlClient.layer),
+        Effect.mapError((error) =>
+          CliError.UserError.make({ cause: error, userMessage: error.message }),
+        ),
+      );
+      yield* terminal.display(
+        `Deployment activated.\n\nApp: ${result.appUrl}\nDeployment: ${result.deploymentId}\n`,
+      );
+      return;
+    }
     const result = yield* runDeploy(path.resolve("."), Option.getOrUndefined(app)).pipe(
       // @effect-diagnostics-next-line strictEffectProvide:off The deploy subcommand owns this client layer for its full lifetime.
       Effect.provide(ControlClient.layer),

package/src/cli/deploy.ts

@@ -15,7 +15,12 @@ import { appUrl, configureApp, type AppConfiguration } from "./app-configuration
 import { buildClient } from "./build/client.js";
 import { buildServer } from "./build/server.js";
 import { generate } from "./codegen.js";
-import { ControlClient, deploymentUploadFiles } from "./control-client.js";
+import {
+  ControlClient,
+  deploymentUploadFiles,
+  type ControlApiError,
+  type ControlClientUnavailable,
+} from "./control-client.js";
 
 export interface DeploymentBuildResult {
   readonly clientAssets: number;
@@ -58,6 +63,18 @@ export class DeploymentActivationUnconfirmed extends Schema.TaggedError<Deployme
   },
 ) {}
 
+const activationError = (
+  deploymentId: DeploymentId,
+  cause: ControlApiError | ControlClientUnavailable,
+) =>
+  cause._tag === "ControlClientUnavailable" || cause.status >= 500
+    ? DeploymentActivationUnconfirmed.make({
+        cause,
+        deploymentId,
+        message: `Deployment ${deploymentId} is ready, but activation could not be confirmed. Run ignotum deploy --resume ${deploymentId} to finish activation.`,
+      })
+    : cause;
+
 const replaceBuildDirectory = Effect.fn("Deploy.replaceBuildDirectory")(function* (
   stateDirectory: string,
   stagingDirectory: string,
@@ -192,16 +209,9 @@ export const uploadDeployment = Effect.fn("Deploy.upload")(function* (
     }),
   );
 
-  yield* control.activateDeployment(configuration.appId, deployment.id).pipe(
-    Effect.catchTags({
-      ControlClientUnavailable: (cause) =>
-        DeploymentActivationUnconfirmed.make({
-          cause,
-          deploymentId: deployment.id,
-          message: `Deployment ${deployment.id} is ready, but activation could not be confirmed.`,
-        }),
-    }),
-  );
+  yield* control
+    .activateDeployment(configuration.appId, deployment.id)
+    .pipe(Effect.mapError((cause) => activationError(deployment.id, cause)));
 
   return deployment.id;
 });
@@ -220,3 +230,16 @@ export const deploy = Effect.fn("Deploy.run")(function* (
     deploymentId,
   } satisfies DeployResult;
 });
+
+export const resumeDeployment = Effect.fn("Deploy.resume")(function* (
+  appDirectory: string,
+  deploymentId: DeploymentId,
+  requestedSlug?: AppSlug,
+) {
+  const configuration = yield* configureApp(appDirectory, requestedSlug);
+  const control = yield* ControlClient;
+  yield* control
+    .activateDeployment(configuration.appId, deploymentId)
+    .pipe(Effect.mapError((cause) => activationError(deploymentId, cause)));
+  return { appUrl: appUrl(configuration.slug), deploymentId };
+});

package/src/client/hooks.ts

@@ -1,3 +1,5 @@
+import { BrowserSession, type IdState } from "./id.js";
+import type { ProfileField } from "@ignotum/contracts/id";
 import { Effect, Schema } from "effect";
 import { useCallback, useDebugValue, useEffect, useMemo, useState } from "preact/hooks";
 
@@ -297,3 +299,69 @@ export const useMutation = <Args extends object | void, Success, Failure extends
     // both call shapes normalize omitted arguments to the empty JSON object.
     return mutate as Mutation<Args, Success, Failure>;
   }, [reference]);
+
+export type IdOptions = {
+  readonly profile?: ReadonlyArray<ProfileField>;
+  readonly returnTo?: string;
+};
+export type IdResult = IdState & {
+  readonly signIn: (options?: IdOptions) => Promise<void>;
+  readonly requestProfile: (
+    fields: ReadonlyArray<ProfileField>,
+    options?: { readonly returnTo?: string },
+  ) => Promise<void>;
+  readonly signOut: () => Promise<void>;
+};
+
+export function useId(): IdResult {
+  const [state, setState] = useState<IdState>({ status: "pending" });
+  useEffect(() => {
+    let active = true;
+    let unsubscribe: (() => void) | undefined;
+    void syncRuntime.runPromise(BrowserSession).then((session) => {
+      if (!active) return;
+      const update = () => setState(session.snapshot());
+      unsubscribe = session.subscribe(update);
+      update();
+    });
+    return () => {
+      active = false;
+      unsubscribe?.();
+    };
+  }, []);
+  const actions = useMemo(
+    () => ({
+      signIn: (options?: IdOptions) =>
+        syncRuntime.runPromise(
+          Effect.gen(function* () {
+            return yield* (yield* BrowserSession).start(
+              "signIn",
+              options?.profile ?? [],
+              options?.returnTo,
+            );
+          }),
+        ),
+      requestProfile: (
+        fields: ReadonlyArray<ProfileField>,
+        options?: { readonly returnTo?: string },
+      ) =>
+        syncRuntime.runPromise(
+          Effect.gen(function* () {
+            return yield* (yield* BrowserSession).start(
+              "requestProfile",
+              fields,
+              options?.returnTo,
+            );
+          }),
+        ),
+      signOut: () =>
+        syncRuntime.runPromise(
+          Effect.gen(function* () {
+            return yield* (yield* BrowserSession).signOut;
+          }),
+        ),
+    }),
+    [],
+  );
+  return { ...state, ...actions };
+}

package/src/client/id.ts

@@ -0,0 +1,259 @@
+import { Context, Effect, Layer, Option, Schema, Semaphore } from "effect";
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+  HttpClientResponse,
+} from "effect/unstable/http";
+import {
+  DevelopmentSelection,
+  developmentSelectionKey,
+  SessionOutcome,
+  SessionRedirect,
+  SessionRequest,
+  SessionResponse,
+  sessionPath,
+  sessionRequestsPath,
+  type ProfileField,
+  type SessionState,
+  type User,
+} from "@ignotum/contracts/id";
+import { IdGenerator } from "@ignotum/shared/id";
+import { SessionEpoch } from "@ignotum/contracts/runtime/id";
+
+export class IdRequestError extends Schema.TaggedError<IdRequestError>()("IdRequestError", {
+  message: Schema.String,
+}) {}
+
+export type IdState =
+  | { readonly status: "pending"; readonly outcome?: SessionOutcome }
+  | { readonly status: "error"; readonly error: string; readonly outcome?: SessionOutcome }
+  | { readonly status: "signedOut"; readonly outcome?: SessionOutcome }
+  | { readonly status: "signedIn"; readonly user: User; readonly outcome?: SessionOutcome };
+
+const outcomeKey = "ignotum.id.outcome";
+const selectionJson = Schema.fromJsonString(DevelopmentSelection);
+
+export class BrowserSession extends Context.Service<
+  BrowserSession,
+  {
+    readonly snapshot: () => IdState;
+    readonly current: () => SessionState | undefined;
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly bootstrap: Effect.Effect<SessionState, IdRequestError>;
+    readonly accept: (session: SessionState, serverTime: number) => void;
+    readonly suspend: (error?: string) => void;
+    readonly socketParameters: () => string;
+    readonly start: (
+      intent: "signIn" | "requestProfile",
+      profile: ReadonlyArray<ProfileField>,
+      returnTo?: string,
+    ) => Effect.Effect<void, IdRequestError>;
+    readonly signOut: Effect.Effect<void, IdRequestError>;
+  }
+>()("ignotum/client/id/BrowserSession") {
+  static readonly layer = Layer.effect(
+    BrowserSession,
+    Effect.gen(function* () {
+      const client = (yield* HttpClient.HttpClient).pipe(HttpClient.filterStatusOk);
+      const ids = yield* IdGenerator;
+      const bootstrapLock = yield* Semaphore.make(1);
+      const listeners = new Set<() => void>();
+      let state: IdState = { status: "pending" };
+      let current: SessionState | undefined;
+      let generation = 0;
+      let deadline = Infinity;
+      let development = false;
+      let selection: DevelopmentSelection | undefined;
+      let expiry: ReturnType<typeof setTimeout> | undefined;
+      const notify = () => {
+        for (const listener of listeners) listener();
+      };
+      const suspend = (error?: string) => {
+        generation += 1;
+        deadline = Infinity;
+        if (expiry !== undefined) clearTimeout(expiry);
+        current = undefined;
+        state =
+          error === undefined
+            ? { status: "pending", outcome: state.outcome }
+            : { status: "error", error, outcome: state.outcome };
+        notify();
+      };
+      const accept = (session: SessionState, serverTime: number) => {
+        generation += 1;
+        if (expiry !== undefined) clearTimeout(expiry);
+        current = session;
+        state =
+          session.user === null
+            ? { status: "signedOut", outcome: state.outcome }
+            : { status: "signedIn", user: session.user, outcome: state.outcome };
+        const delay = Math.max(0, session.validUntil - serverTime);
+        deadline = performance.now() + delay;
+        if (delay < 2_147_483_647) expiry = setTimeout(() => suspend(), delay);
+        notify();
+      };
+      const checkExpiry = () => {
+        if (current !== undefined && performance.now() >= deadline) suspend();
+      };
+      globalThis.addEventListener?.("focus", checkExpiry);
+      globalThis.document?.addEventListener("visibilitychange", checkExpiry);
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          if (expiry !== undefined) clearTimeout(expiry);
+          listeners.clear();
+          globalThis.removeEventListener?.("focus", checkExpiry);
+          globalThis.document?.removeEventListener("visibilitychange", checkExpiry);
+        }),
+      );
+
+      const readOutcome = () => {
+        const raw = globalThis.sessionStorage.getItem(outcomeKey);
+        if (raw !== null) {
+          const decoded = Schema.decodeUnknownOption(SessionOutcome)(raw);
+          if (Option.isSome(decoded)) state = { ...state, outcome: decoded.value };
+          globalThis.sessionStorage.removeItem(outcomeKey);
+        }
+      };
+      const parameters = () => {
+        if (!development || selection === undefined) return "";
+        const params = new URLSearchParams({ epoch: selection.epoch });
+        if (selection.username !== null) params.set("username", selection.username);
+        return `?${params}`;
+      };
+      const readSession = Effect.fn("BrowserSession.read")(function* () {
+        return yield* client
+          .get(`${sessionPath}${parameters()}`, { headers: { "x-ignotum-request": "1" } })
+          .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(SessionResponse)));
+      });
+      let bootstrapGeneration = 0;
+      const bootstrap = bootstrapLock
+        .withPermits(1)(
+          Effect.gen(function* () {
+            const admittedGeneration = generation;
+            bootstrapGeneration = admittedGeneration;
+            const startedAt = performance.now();
+            let session = yield* readSession();
+            development = session.development === true;
+            if (development && selection === undefined) {
+              const saved = globalThis.sessionStorage.getItem(developmentSelectionKey);
+              const decoded =
+                saved === null
+                  ? Option.none<DevelopmentSelection>()
+                  : Schema.decodeOption(selectionJson)(saved);
+              selection = Option.getOrElse(decoded, () => ({
+                formatVersion: 1 as const,
+                username: null,
+                epoch: "",
+              }));
+              if (selection.epoch === "")
+                selection = { ...selection, epoch: yield* ids.generate(SessionEpoch) };
+              globalThis.sessionStorage.setItem(
+                developmentSelectionKey,
+                Schema.encodeSync(selectionJson)(selection),
+              );
+              session = yield* readSession();
+            }
+            if (generation !== admittedGeneration) {
+              if (current !== undefined) return current;
+              return yield* IdRequestError.make({
+                message: "Your ID session changed while loading.",
+              });
+            }
+            readOutcome();
+            if (session.outcome !== undefined) state = { ...state, outcome: session.outcome };
+            accept(session, session.serverTime + performance.now() - startedAt);
+            return session;
+          }),
+        )
+        .pipe(
+          Effect.mapError(() =>
+            IdRequestError.make({ message: "Could not load your ID session." }),
+          ),
+          Effect.tapError((error) =>
+            Effect.sync(() => {
+              if (generation === bootstrapGeneration) suspend(error.message);
+            }),
+          ),
+        );
+
+      const start = Effect.fn("BrowserSession.start")(function* (
+        intent: "signIn" | "requestProfile",
+        profile: ReadonlyArray<ProfileField>,
+        returnTo?: string,
+      ) {
+        const session = current ?? (yield* bootstrap);
+        if (intent === "requestProfile" && session.user === null)
+          return yield* IdRequestError.make({
+            message: "Sign in before requesting profile information.",
+          });
+        const request = yield* Schema.decodeUnknownEffect(SessionRequest)({
+          intent,
+          profile,
+          sessionEpoch: session.sessionEpoch,
+          returnTo:
+            returnTo ??
+            `${globalThis.location.pathname}${globalThis.location.search}${globalThis.location.hash}`,
+        }).pipe(
+          Effect.mapError(() => IdRequestError.make({ message: "The ID request is invalid." })),
+        );
+        const redirect = yield* HttpClientRequest.post(sessionRequestsPath).pipe(
+          HttpClientRequest.setHeader("x-ignotum-request", "1"),
+          HttpClientRequest.bodyJsonUnsafe(request),
+          client.execute,
+          Effect.flatMap(HttpClientResponse.schemaBodyJson(SessionRedirect)),
+          Effect.mapError(() =>
+            IdRequestError.make({ message: "Could not start the ID request." }),
+          ),
+        );
+        if (current?.sessionEpoch !== session.sessionEpoch)
+          return yield* IdRequestError.make({ message: "Your ID session changed. Try again." });
+        globalThis.location.assign(redirect.redirectUrl);
+      });
+      const signOut = Effect.gen(function* () {
+        const session = current ?? (yield* bootstrap);
+        yield* HttpClientRequest.delete(sessionPath).pipe(
+          HttpClientRequest.setHeader("x-ignotum-request", "1"),
+          HttpClientRequest.bodyJsonUnsafe({ sessionEpoch: session.sessionEpoch }),
+          client.execute,
+          Effect.mapError(() => IdRequestError.make({ message: "Could not sign out." })),
+        );
+        suspend();
+        if (development) {
+          selection = {
+            formatVersion: 1,
+            username: null,
+            epoch: yield* ids.generate(SessionEpoch),
+          };
+          globalThis.sessionStorage.setItem(
+            developmentSelectionKey,
+            Schema.encodeSync(selectionJson)(selection),
+          );
+        }
+        globalThis.location.reload();
+      });
+      return BrowserSession.of({
+        snapshot: () => {
+          checkExpiry();
+          return state;
+        },
+        current: () => {
+          checkExpiry();
+          return current;
+        },
+        subscribe: (listener) => {
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        },
+        accept,
+        suspend,
+        bootstrap,
+        start,
+        signOut,
+        socketParameters: parameters,
+      });
+    }),
+  ).pipe(Layer.provide(FetchHttpClient.layer));
+}

package/src/client/index.ts

@@ -16,7 +16,7 @@ export type {
   FileValue,
 } from "@ignotum/contracts/schema/file";
 export { Files } from "./files.js";
-export { useMutation, usePaginatedQuery, useQuery } from "./hooks.js";
+export { useId, useMutation, usePaginatedQuery, useQuery } from "./hooks.js";
 export type { PaginatedQueryOptions, PaginatedQueryValue, PaginationStatus } from "./hooks.js";
 export { Query } from "./query.js";
 export type { QuerySkip } from "./query.js";
@@ -89,7 +89,7 @@ export {
   useDebugValue,
   useEffect,
   useErrorBoundary,
-  useId,
+  useId as useElementId,
   useImperativeHandle,
   useLayoutEffect,
   useMemo,
@@ -98,3 +98,6 @@ export {
   useState,
 } from "preact/hooks";
 export type { Dispatch, Reducer, StateUpdater } from "preact/hooks";
+
+export type { User, UserId, ProfileField } from "@ignotum/contracts/id";
+export type { IdResult, IdOptions } from "./hooks.js";