ignotum 0.0.11 → 0.0.13

package/src/dev-runtime/functions.ts

@@ -1,3 +1,4 @@
+import { makeIdContext, type IdContext, type SessionState } from "@ignotum/contracts/id";
 import {
   FunctionUnavailable,
   InvalidArguments,
@@ -6,12 +7,21 @@ import {
   type FunctionKind,
   type FunctionResolutionError,
 } from "@ignotum/contracts/runtime/functions";
-import { type RuntimeSchemaDefinition } from "@ignotum/contracts/runtime/schema";
+import {
+  getFunctionEnvironment,
+  type RuntimeSchemaDefinition,
+} from "@ignotum/contracts/runtime/schema";
 import { ErrorValueSchema, type ErrorValue } from "@ignotum/contracts/runtime/result";
 import { RequestId } from "@ignotum/contracts/runtime/id";
 import { IdGenerator } from "@ignotum/shared/id";
 import { encodedFileOccurrencesOf } from "@ignotum/contracts/schema/file";
 import type { RuntimeInvocationResult } from "@ignotum/contracts/runtime/hosted";
+import {
+  emptyEnv,
+  isDefinedEnv,
+  type DefinedEnv,
+  type EnvironmentType,
+} from "@ignotum/contracts/schema";
 import {
   FunctionAddress,
   apiFunctionParts,
@@ -21,7 +31,19 @@ import {
   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 {
+  Cause,
+  Context,
+  Effect,
+  FileSystem,
+  Layer,
+  Path,
+  Predicate,
+  Ref,
+  Result,
+  Schema,
+  Semaphore,
+} from "effect";
 import type { ViteDevServer } from "vite";
 import { normalizePath } from "vite";
 
@@ -31,17 +53,92 @@ import {
   type FunctionArguments,
   type RuntimeFunctionDefinition as InternalRuntimeFunctionDefinition,
 } from "../internal/function-definition.js";
+import {
+  EnvironmentConfigurationInvalid,
+  loadEnvironment,
+  type LoadedEnvironment,
+} from "../cli/environment.js";
 
 export { FunctionUnavailable, InvalidArguments, UnknownFunction, WrongFunctionKind };
 export type { FunctionArguments, FunctionKind };
 
-export type RuntimeHandlerContext = LocalMutationContext | LocalQueryContext;
+export type RuntimeHandlerContext = (LocalMutationContext | LocalQueryContext) & {
+  readonly id: IdContext;
+};
 export type RuntimeFunctionDefinition = InternalRuntimeFunctionDefinition<RuntimeHandlerContext>;
 
+const loadDevelopmentEnvironment = Effect.fn("DevelopmentEnvironment.load")(function* (
+  server: ViteDevServer,
+  appDirectory: string,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const definitionPath = path.join(appDirectory, "server", "env.ts");
+  const hasDefinition = yield* fileSystem.exists(definitionPath);
+  if (!hasDefinition) return yield* loadEnvironment(appDirectory, emptyEnv, false);
+  const loaded = yield* Effect.tryPromise({
+    try: () => server.ssrLoadModule(normalizePath(definitionPath)),
+    catch: () =>
+      EnvironmentConfigurationInvalid.make({
+        message: "Ignotum could not load server/env.ts.",
+        path: definitionPath,
+      }),
+  });
+  if (!Predicate.isObject(loaded.default) || !isDefinedEnv(loaded.default)) {
+    return yield* EnvironmentConfigurationInvalid.make({
+      message: "The default export from server/env.ts is not an Ignotum environment.",
+      path: definitionPath,
+    });
+  }
+  return yield* loadEnvironment(appDirectory, loaded.default, true);
+});
+
+export class DevelopmentEnvironment extends Context.Service<
+  DevelopmentEnvironment,
+  {
+    readonly reload: Effect.Effect<void, unknown>;
+    readonly snapshot: Effect.Effect<LoadedEnvironment, unknown>;
+  }
+>()("ignotum/dev-runtime/functions/DevelopmentEnvironment") {
+  static layer(server: ViteDevServer, appDirectory: string) {
+    return Layer.effect(
+      DevelopmentEnvironment,
+      Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const load = loadDevelopmentEnvironment(server, appDirectory).pipe(
+          Effect.provideService(FileSystem.FileSystem, fileSystem),
+          Effect.provideService(Path.Path, path),
+        );
+        const initial = yield* load;
+        const current = yield* Ref.make<Result.Result<LoadedEnvironment, unknown>>(
+          Result.succeed(initial),
+        );
+        const fromResult = Result.match({
+          onFailure: Effect.fail,
+          onSuccess: Effect.succeed,
+        });
+        const reload = load.pipe(
+          Effect.result,
+          Effect.flatMap((result) =>
+            Ref.set(current, result).pipe(Effect.andThen(fromResult(result))),
+          ),
+          Effect.asVoid,
+        );
+        return DevelopmentEnvironment.of({
+          reload,
+          snapshot: Ref.get(current).pipe(Effect.flatMap(fromResult)),
+        });
+      }),
+    );
+  }
+}
+
 export interface ResolvedFunction {
   readonly definition: RuntimeFunctionDefinition;
   readonly args: FunctionArguments;
   readonly schema: RuntimeSchemaDefinition;
+  readonly environment?: Readonly<EnvironmentType<DefinedEnv>>;
 }
 
 export class FunctionRegistry extends Context.Service<
@@ -59,6 +156,7 @@ export class FunctionRegistry extends Context.Service<
       FunctionRegistry,
       Effect.gen(function* () {
         const path = yield* Path.Path;
+        const developmentEnvironment = yield* DevelopmentEnvironment;
         return FunctionRegistry.of({
           resolve: Effect.fn("FunctionRegistry.resolve")(function* (functionAddress, kind, args) {
             const { functionName, moduleName } = apiFunctionParts(functionAddress);
@@ -84,6 +182,14 @@ export class FunctionRegistry extends Context.Service<
               });
             }
             const definition = inspected.definition;
+            const environmentDefinition = getFunctionEnvironment(candidate);
+            if (environmentDefinition === undefined) {
+              return yield* FunctionUnavailable.make({
+                cause: new Error(`${functionAddress} has no environment binding.`),
+                function: functionAddress,
+                message: `Could not load ${functionAddress}.`,
+              });
+            }
 
             if (definition._tag !== kind) {
               return yield* WrongFunctionKind.make({
@@ -105,7 +211,22 @@ export class FunctionRegistry extends Context.Service<
               ),
             );
 
-            return { args: decodedArgs, definition, schema: inspected.schema };
+            const loadedEnvironment = yield* developmentEnvironment.snapshot.pipe(
+              Effect.mapError((cause) =>
+                FunctionUnavailable.make({
+                  cause,
+                  function: functionAddress,
+                  message: `Could not load ${functionAddress}.`,
+                }),
+              ),
+            );
+
+            return {
+              args: decodedArgs,
+              definition,
+              environment: loadedEnvironment.value,
+              schema: inspected.schema,
+            };
           }),
         });
       }),
@@ -125,6 +246,7 @@ export class FunctionExecutor extends Context.Service<
       functionAddress: FunctionAddress,
       kind: FunctionKind,
       resolved: ResolvedFunction,
+      identity?: SessionState,
     ) => Effect.Effect<RuntimeInvocationResult>;
   }
 >()("ignotum/dev-runtime/functions/FunctionExecutor") {
@@ -164,91 +286,113 @@ export class FunctionExecutor extends Context.Service<
         );
 
       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),
+        execute: Effect.fn("FunctionExecutor.execute")(
+          function* (functionAddress, kind, resolved, identity) {
+            let readId = false;
+            const id = makeIdContext(
+              Effect.sync(() => {
+                readId = true;
+                return identity?.user ?? null;
               }),
             );
+            const invoke = (context: LocalMutationContext | LocalQueryContext) =>
+              Effect.gen(() =>
+                resolved.definition.handler(
+                  Object.freeze({ ...context, id, env: resolved.environment ?? Object.freeze({}) }),
+                  resolved.args,
+                ),
+              ).pipe(
+                Effect.matchEffect({
+                  onFailure: (error) => encodeFailure(resolved.definition, error),
+                  onSuccess: (value) => encodeSuccess(resolved.definition, value),
+                }),
+              );
 
-          const execution =
-            kind === "Query"
-              ? database.trackedQueryTransaction(resolved.schema, invoke).pipe(
-                  Effect.map(
-                    ({ dependencies, observedRevision, value }): RuntimeInvocationResult => {
-                      const files =
-                        value.type === "Success" && value.value !== undefined
-                          ? encodedFileOccurrencesOf(value.value)
-                          : [];
-                      const result = {
-                        type: "Query",
-                        result: value,
-                        dependencies,
-                        observedRevision,
-                      } as const;
-                      return files.length === 0 ? result : { ...result, files };
-                    },
-                  ),
-                )
-              : mutationSemaphore.withPermits(1)(
-                  database
-                    .trackedMutationTransaction(resolved.schema, (context) =>
-                      invoke(context).pipe(
-                        Effect.flatMap((result) =>
-                          result.type === "Failure"
-                            ? Effect.fail(MutationApplicationFailure.make({ error: result.error }))
-                            : Effect.succeed(result),
-                        ),
-                      ),
-                    )
-                    .pipe(
-                      Effect.map(
-                        ({ committedRevision, invalidations, value }): RuntimeInvocationResult => ({
-                          type: "Mutation",
+            const execution =
+              kind === "Query"
+                ? database.trackedQueryTransaction(resolved.schema, invoke).pipe(
+                    Effect.map(
+                      ({ dependencies, observedRevision, value }): RuntimeInvocationResult => {
+                        const files =
+                          value.type === "Success" && value.value !== undefined
+                            ? encodedFileOccurrencesOf(value.value)
+                            : [];
+                        const result = {
+                          type: "Query",
                           result: value,
-                          invalidations,
-                          committedRevision,
-                        }),
-                      ),
-                      Effect.catchTags({
-                        MutationApplicationFailure: ({ error }) =>
-                          Effect.succeed<RuntimeInvocationResult>({
+                          dependencies: readId
+                            ? [...dependencies, { type: "Id" as const }]
+                            : dependencies,
+                          observedRevision,
+                        } as const;
+                        return files.length === 0 ? result : { ...result, files };
+                      },
+                    ),
+                  )
+                : mutationSemaphore.withPermits(1)(
+                    database
+                      .trackedMutationTransaction(resolved.schema, (context) =>
+                        invoke(context).pipe(
+                          Effect.flatMap((result) =>
+                            result.type === "Failure"
+                              ? Effect.fail(
+                                  MutationApplicationFailure.make({ error: result.error }),
+                                )
+                              : Effect.succeed(result),
+                          ),
+                        ),
+                      )
+                      .pipe(
+                        Effect.map(
+                          ({
+                            committedRevision,
+                            invalidations,
+                            value,
+                          }): RuntimeInvocationResult => ({
                             type: "Mutation",
-                            result: { type: "Failure", error },
+                            result: value,
+                            invalidations,
+                            committedRevision,
                           }),
-                      }),
-                    ),
-                );
-
-          return yield* execution.pipe(
-            Effect.orDie,
-            Effect.catchCauseIf(
-              (cause) => !Cause.hasInterruptsOnly(cause),
-              (cause) =>
-                Effect.gen(function* () {
-                  const requestId = yield* ids.generate(RequestId);
-                  yield* Effect.logError(`${functionAddress} failed during execution.`).pipe(
-                    Effect.annotateLogs({ cause, function: functionAddress, requestId }),
+                        ),
+                        Effect.catchTags({
+                          MutationApplicationFailure: ({ error }) =>
+                            Effect.succeed<RuntimeInvocationResult>({
+                              type: "Mutation",
+                              result: { type: "Failure", error },
+                            }),
+                        }),
+                      ),
                   );
-                  const result = {
-                    type: "Failure" as const,
-                    error: { _tag: "InternalServerError", requestId },
-                  };
-                  if (kind === "Mutation") {
-                    return { type: "Mutation" as const, result };
-                  }
-                  return {
-                    type: "Query" as const,
-                    result,
-                    dependencies: [],
-                    observedRevision: yield* database.revision,
-                  };
-                }),
-            ),
-          );
-        }),
+
+            return yield* execution.pipe(
+              Effect.orDie,
+              Effect.catchCauseIf(
+                (cause) => !Cause.hasInterruptsOnly(cause),
+                (cause) =>
+                  Effect.gen(function* () {
+                    const requestId = yield* ids.generate(RequestId);
+                    yield* Effect.logError(`${functionAddress} failed during execution.`).pipe(
+                      Effect.annotateLogs({ cause, function: functionAddress, requestId }),
+                    );
+                    const result = {
+                      type: "Failure" as const,
+                      error: { _tag: "InternalServerError", requestId },
+                    };
+                    if (kind === "Mutation") {
+                      return { type: "Mutation" as const, result };
+                    }
+                    return {
+                      type: "Query" as const,
+                      result,
+                      dependencies: readId ? [{ type: "Id" as const }] : [],
+                      observedRevision: yield* database.revision,
+                    };
+                  }),
+              ),
+            );
+          },
+        ),
       });
     }),
   );
@@ -261,10 +405,12 @@ export const functionRuntimeLayer = Layer.effect(
     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) };
-      }),
+      prepare: Effect.fn("DevFunctionRuntime.prepare")(
+        function* (functionAddress, kind, args, identity) {
+          const resolved = yield* registry.resolve(functionAddress, kind, args);
+          return { execute: executor.execute(functionAddress, kind, resolved, identity) };
+        },
+      ),
     });
   }),
 );

package/src/dev-runtime/id.ts

@@ -1,3 +1,175 @@
-import { IdGenerator } from "@ignotum/shared/id";
+import { Context, Effect, FileSystem, Layer, Path, Schema, Semaphore } from "effect";
+import {
+  DevelopmentUsername,
+  developmentSelectionKey,
+  ProfileFields,
+  SessionRequest,
+  User,
+  UserId,
+  type SessionState,
+} from "@ignotum/contracts/id";
+import * as Versioned from "@ignotum/contracts/versioned";
 
-export const idGeneratorLayer = IdGenerator.layer;
+const Profile = Schema.Struct({ user: User, share: ProfileFields, revision: Schema.Natural });
+const ProfilesV1 = Schema.Struct({
+  formatVersion: Schema.Literal(1),
+  profiles: Schema.Record(Schema.String, Profile),
+});
+const Profiles = Versioned.initial(ProfilesV1);
+const ProfilesJson = Schema.fromJsonString(Profiles);
+
+export const localIdPath = "/_ignotum/v1/id";
+export const LocalCompletion = Schema.Struct({
+  request: SessionRequest,
+  username: DevelopmentUsername,
+  name: Schema.String,
+  email: Schema.String,
+  image: Schema.String,
+  share: ProfileFields,
+  manage: Schema.optional(Schema.Boolean),
+});
+
+const projection = (user: User, share: ReadonlyArray<string>): User => ({
+  id: user.id,
+  name: share.includes("name") ? user.name : undefined,
+  email: share.includes("email") ? user.email : undefined,
+  image: share.includes("image") ? user.image : undefined,
+});
+
+export class LocalId extends Context.Service<
+  LocalId,
+  {
+    readonly profile: (username: string) => Effect.Effect<typeof Profile.Type | undefined>;
+    readonly session: (username: string | null, epoch: string) => Effect.Effect<SessionState>;
+    readonly complete: (input: typeof LocalCompletion.Type) => Effect.Effect<void>;
+  }
+>()("ignotum/dev-runtime/id/LocalId") {
+  static readonly layer = (directory: string) =>
+    Layer.effect(
+      LocalId,
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const file = path.join(directory, ".ignotum", "id.json");
+        const lock = yield* Semaphore.make(1);
+        const load = Effect.fn("LocalId.load")(function* () {
+          if (!(yield* fs.exists(file))) return Profiles.make({ formatVersion: 1, profiles: {} });
+          return yield* fs
+            .readFileString(file)
+            .pipe(Effect.flatMap(Schema.decodeEffect(ProfilesJson)));
+        });
+        return LocalId.of({
+          profile: Effect.fn("LocalId.profile")(function* (username) {
+            return (yield* load().pipe(Effect.orDie)).profiles[username];
+          }),
+          session: Effect.fn("LocalId.session")(function* (username, epoch) {
+            if (username === null)
+              return {
+                sessionEpoch: epoch,
+                viewRevision: 0,
+                user: null,
+                validUntil: Number.MAX_SAFE_INTEGER,
+              };
+            const id = yield* Schema.decodeEffect(UserId)(username).pipe(Effect.orDie);
+            const profile = (yield* load().pipe(Effect.orDie)).profiles[id];
+            const user: User = projection(profile?.user ?? { id }, profile?.share ?? []);
+            return {
+              sessionEpoch: epoch,
+              viewRevision: profile?.revision ?? 0,
+              user,
+              validUntil: Number.MAX_SAFE_INTEGER,
+            };
+          }),
+          complete: Effect.fn("LocalId.complete")(function* (input) {
+            yield* lock
+              .withPermits(1)(
+                Effect.gen(function* () {
+                  const stored = yield* load();
+                  const previous = stored.profiles[input.username];
+                  const user = User.make({
+                    id: UserId.make(input.username),
+                    name: input.name === "" ? undefined : input.name,
+                    email: input.email === "" ? undefined : input.email,
+                    image: input.image === "" ? undefined : input.image,
+                  });
+                  const share =
+                    input.manage === true
+                      ? input.share
+                      : [
+                          ...new Set([
+                            ...(previous?.share ?? []),
+                            ...input.share.filter((field) => input.request.profile.includes(field)),
+                          ]),
+                        ];
+                  const updated = Profiles.make({
+                    formatVersion: 1,
+                    profiles: {
+                      ...stored.profiles,
+                      [input.username]: {
+                        user,
+                        share,
+                        revision:
+                          (previous?.revision ?? 0) +
+                          Number(
+                            JSON.stringify(
+                              projection(previous?.user ?? { id: user.id }, previous?.share ?? []),
+                            ) !== JSON.stringify(projection(user, share)),
+                          ),
+                      },
+                    },
+                  });
+                  yield* fs.makeDirectory(path.dirname(file), { recursive: true });
+                  yield* Effect.scoped(
+                    Effect.gen(function* () {
+                      const temporary = yield* fs.makeTempFileScoped({
+                        directory: path.dirname(file),
+                        prefix: ".id-",
+                      });
+                      yield* fs.writeFileString(
+                        temporary,
+                        yield* Schema.encodeEffect(ProfilesJson)(updated),
+                      );
+                      yield* fs.rename(temporary, file);
+                    }),
+                  );
+                }),
+              )
+              .pipe(Effect.orDie);
+          }),
+        });
+      }),
+    );
+}
+
+const escapeHtml = (text: string) =>
+  text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll('"', "&quot;");
+
+export const localIdPage = (request: typeof SessionRequest.Type): string => {
+  const encoded = JSON.stringify(request).replaceAll("<", "\\u003c");
+  return `<!doctype html><html><head><meta charset="utf-8"><title>Ignotum ID · Development</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1"><style>
+  body{font:16px system-ui;background:#f7f7f5;color:#20211f;max-width:420px;margin:8vh auto;padding:24px}
+  label{display:block;margin:16px 0}input:not([type=checkbox]){box-sizing:border-box;width:100%;padding:10px;border:1px solid #bbb;border-radius:6px}
+  button{padding:12px 18px;border:0;border-radius:6px;background:#222;color:white;cursor:pointer;margin-right:8px}
+  p{line-height:1.5}small{color:#666}</style></head><body><h1>Ignotum ID</h1><p>Choose a local username to try your app.</p>
+  <form id="form"><label>Username<input name="username" required pattern="[a-z][a-z0-9_-]{0,63}" placeholder="john"></label>
+  <label>Name<input name="name"></label><label>Email<input name="email" type="email"></label><label>Image URL<input name="image" type="url"></label>
+  ${["name", "email", "image"].map((field) => `<label><input type="checkbox" name="share" value="${escapeHtml(field)}"> Share ${escapeHtml(field)}</label>`).join("")}
+  <label><input type="checkbox" name="manage"> Replace existing sharing choices</label>
+  <p><small>Profile sharing is optional. No password or account is needed in development.</small></p>
+  <button>Continue</button><button type="button" id="cancel">Cancel</button><p id="error"></p></form>
+  <script type="module">
+  const request=${encoded};const form=document.querySelector('#form');
+  const previous=JSON.parse(sessionStorage.getItem('${developmentSelectionKey}')||'null');
+  if(previous?.username)form.elements.username.value=previous.username;
+  if(request.intent==='requestProfile')form.elements.username.readOnly=true;
+  let loading=false;const loadProfile=async()=>{loading=true;try{const response=await fetch('${localIdPath}/profile?username='+encodeURIComponent(form.elements.username.value),{headers:{'x-ignotum-request':'1'}});if(!response.ok)throw new Error('Could not load the local profile.');const profile=await response.json();for(const field of ['name','email','image']){form.elements[field].value=profile?.user[field]??'';form.querySelector('input[name=share][value='+field+']').checked=profile?.share.includes(field)??false;}}finally{loading=false;}};form.elements.username.onchange=loadProfile;if(previous?.username)await loadProfile();
+  document.querySelector('#cancel').onclick=()=>{sessionStorage.setItem('ignotum.id.outcome','Cancelled');location.replace(request.returnTo)};
+  form.onsubmit=async(e)=>{e.preventDefault();if(loading)return;const data=new FormData(form);
+    try{const response=await fetch('${localIdPath}',{method:'POST',headers:{'content-type':'application/json','x-ignotum-request':'1'},body:JSON.stringify({request,username:data.get('username'),name:data.get('name'),email:data.get('email'),image:data.get('image'),share:data.getAll('share'),manage:data.get('manage')==='on'})});
+    if(!response.ok)throw new Error('Could not update your local ID.');
+    sessionStorage.setItem('${developmentSelectionKey}',JSON.stringify({formatVersion:1,username:data.get('username'),epoch:request.intent==='requestProfile'?previous.epoch:'dev:'+crypto.randomUUID()}));
+    sessionStorage.setItem('ignotum.id.outcome',request.intent==='requestProfile'?'ProfileUpdated':'SignedIn');location.replace(request.returnTo);
+    }catch(error){document.querySelector('#error').textContent=error.message}}
+  </script></body></html>`;
+};