ignotum 0.0.12 → 0.0.13

package/dist/runtime/server.d.ts

@@ -1,6 +1,8 @@
-import { c as Result$1, g as FileValue, h as FileMimeType, i as ErrorValue, m as FileMetadata, p as FileFormat } from "./id-Cs82tq9Q-CK-maMgN.js";
-import "./result-DIjKM-p4.js";
-import { a as DefinedEnv, d as defineEnv$1, f as Secret$1, i as defineSchema$1, n as SchemaAuthoring, s as EnvironmentAuthoring, t as DefinedSchema } from "./index-CrWg4Z0y.js";
+import { c as Result$1, g as FileValue, h as FileMimeType, i as ErrorValue, m as FileMetadata, p as FileFormat } from "./id-BzFHf3Wo-DGPCjgrf.js";
+import "./result-DKAA4gpS.js";
+import { d as User, f as UserId } from "./pagination-DnKg3dkI-r5ZUxBBx.js";
+import "./id-Dz0apuB3.js";
+import { a as DefinedEnv, d as defineEnv$1, f as Secret$1, i as defineSchema$1, n as SchemaAuthoring, s as EnvironmentAuthoring, t as DefinedSchema } from "./index-D54flWtH.js";
 //#region src/server/index.d.ts
 declare const Result: typeof Result$1;
 type Result<Success, Failure extends ErrorValue> = Result$1<Success, Failure>;
@@ -9,5 +11,5 @@ declare const defineSchema: typeof defineSchema$1;
 declare const Secret: typeof Secret$1;
 type Secret<Value> = Secret$1<Value>;
 //#endregion
-export { type DefinedEnv, type DefinedSchema, type EnvironmentAuthoring, type FileFormat, type FileMetadata, type FileMimeType, type FileValue, Result, type SchemaAuthoring, Secret, defineEnv, defineSchema };
+export { type DefinedEnv, type DefinedSchema, type EnvironmentAuthoring, type FileFormat, type FileMetadata, type FileMimeType, type FileValue, Result, type SchemaAuthoring, Secret, type User, type UserId, defineEnv, defineSchema };
 //# sourceMappingURL=server.d.ts.map

package/dist/runtime/server.js

@@ -1,5 +1,5 @@
-import { f as Result$1 } from "./descriptor-XzDX2JDw-j3O6YHgW.js";
-import { a as defineSchema$1, i as defineEnv$1, l as Secret$1 } from "./schema-B9XxyRO8.js";
+import { _ as Result$1 } from "./id-Bt9XWRGL.js";
+import { a as defineSchema$1, i as defineEnv$1, l as Secret$1 } from "./schema-1Zs03-iS.js";
 //#region src/server/index.ts
 const Result = Result$1;
 const defineEnv = defineEnv$1;

package/dist/runtime/server.js.map

@@ -1 +1 @@
-{"version":3,"file":"server.js","names":["contractResult","defineContractEnv","defineContractSchema","contractSecret"],"sources":["../../src/server/index.ts"],"sourcesContent":["import { Result as contractResult } from \"@ignotum/contracts/runtime/result\";\nimport type { ErrorValue, Result as ContractResult } from \"@ignotum/contracts/runtime/result\";\nimport {\n  defineEnv as defineContractEnv,\n  defineSchema as defineContractSchema,\n  Secret as contractSecret,\n} from \"@ignotum/contracts/schema\";\nimport type { Secret as ContractSecret } from \"@ignotum/contracts/schema\";\n\nexport const Result: typeof contractResult = contractResult;\nexport type Result<Success, Failure extends ErrorValue> = ContractResult<Success, Failure>;\nexport const defineEnv: typeof defineContractEnv = defineContractEnv;\nexport const defineSchema: typeof defineContractSchema = defineContractSchema;\nexport const Secret: typeof contractSecret = contractSecret;\nexport type Secret<Value> = ContractSecret<Value>;\nexport type {\n  DefinedEnv,\n  DefinedSchema,\n  EnvironmentAuthoring,\n  FileFormat,\n  FileMetadata,\n  FileMimeType,\n  FileValue,\n  SchemaAuthoring,\n} from \"@ignotum/contracts/schema\";\n"],"mappings":";;;AASA,MAAa,SAAgCA;AAE7C,MAAa,YAAsCC;AACnD,MAAa,eAA4CC;AACzD,MAAa,SAAgCC"}
+{"version":3,"file":"server.js","names":["contractResult","defineContractEnv","defineContractSchema","contractSecret"],"sources":["../../src/server/index.ts"],"sourcesContent":["import { Result as contractResult } from \"@ignotum/contracts/runtime/result\";\nimport type { ErrorValue, Result as ContractResult } from \"@ignotum/contracts/runtime/result\";\nimport {\n  defineEnv as defineContractEnv,\n  defineSchema as defineContractSchema,\n  Secret as contractSecret,\n} from \"@ignotum/contracts/schema\";\nimport type { Secret as ContractSecret } from \"@ignotum/contracts/schema\";\n\nexport const Result: typeof contractResult = contractResult;\nexport type Result<Success, Failure extends ErrorValue> = ContractResult<Success, Failure>;\nexport const defineEnv: typeof defineContractEnv = defineContractEnv;\nexport const defineSchema: typeof defineContractSchema = defineContractSchema;\nexport const Secret: typeof contractSecret = contractSecret;\nexport type Secret<Value> = ContractSecret<Value>;\nexport type {\n  DefinedEnv,\n  DefinedSchema,\n  EnvironmentAuthoring,\n  FileFormat,\n  FileMetadata,\n  FileMimeType,\n  FileValue,\n  SchemaAuthoring,\n} from \"@ignotum/contracts/schema\";\n\nexport type { User, UserId } from \"@ignotum/contracts/id\";\n"],"mappings":";;;AASA,MAAa,SAAgCA;AAE7C,MAAa,YAAsCC;AACnD,MAAa,eAA4CC;AACzD,MAAa,SAAgCC"}

package/dist/runtime/{sync-avN7NkcU.d.ts → sync-Bs8J3fIr.d.ts}

@@ -1,8 +1,8 @@
-import "./id-Cs82tq9Q-CK-maMgN.js";
+import "./id-BzFHf3Wo-DGPCjgrf.js";
 import { Schema } from "effect";
 //#region ../contracts/dist/runtime/sync.d.ts
 declare const FunctionAddress: Schema.TemplateLiteral<readonly ["api.", Schema.String, ".", Schema.String]>;
 type FunctionAddress = typeof FunctionAddress.Type;
 //#endregion
 export { FunctionAddress as t };
-//# sourceMappingURL=sync-avN7NkcU.d.ts.map
+//# sourceMappingURL=sync-Bs8J3fIr.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignotum",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Ignotum is an opinionated TypeScript application cloud.",
   "author": "Johannes Schießl",
   "repository": {

package/src/cli/agent-files.ts

@@ -1,3 +1,6 @@
+import authentication from "../../../../docs/user/authentication.md?raw";
+import profileSharing from "../../../../docs/user/profile-sharing.md?raw";
+import localAuthentication from "../../../../docs/user/local-authentication.md?raw";
 import agents from "../../../../docs/agent/AGENTS.md?raw";
 import skill from "../../../../docs/agent/skills/ignotum/SKILL.md?raw";
 import api from "../../../../docs/user/api.md?raw";
@@ -38,6 +41,9 @@ export interface AppFile {
 }
 
 const references = [
+  ["authentication.md", authentication],
+  ["profile-sharing.md", profileSharing],
+  ["local-authentication.md", localAuthentication],
   ["api.md", api],
   ["app-entry.md", appEntry],
   ["cli.md", cli],

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";