@bomb.sh/router 0.0.1 → 0.7.0

package/src/lib/env.ts

@@ -0,0 +1,142 @@
+import type { Maybe } from "./maybe.js";
+import type { AnyParam } from "./param.js";
+import { brand, type IdentityElement } from "./pipeline.js";
+import type { AnyRoute, RoutePath } from "./types.js";
+
+export interface EnvSource {
+  readonly name: string;
+  readonly value: Environment;
+}
+
+export type Environment = Readonly<Record<string, string | undefined>>;
+
+export interface EnvClaim {
+  readonly result: Maybe<{
+    readonly source: string;
+    readonly address: readonly string[];
+    readonly key: string;
+    readonly value: string;
+  }>;
+  readonly rest: Envs;
+}
+
+export interface EnvClaimOptions {
+  readonly route: readonly string[];
+  readonly address: readonly string[];
+  readonly key?: string;
+}
+
+export function env(
+  key: string,
+): IdentityElement<AnyParam> {
+  return brand<IdentityElement<AnyParam>>(
+    (param: AnyParam) => ({ ...param, env: key }),
+  );
+}
+
+export function withEnvs(
+  envs: readonly EnvSource[],
+): IdentityElement<AnyRoute> {
+  return brand<IdentityElement<AnyRoute>>(
+    (route: AnyRoute) => {
+      let phases = [...route.phases];
+      let phase = phases.pop()!;
+      phases.push({
+        ...phase,
+        envs: phase.envs.concat(envs),
+      });
+      return {
+        ...route,
+        phases,
+      };
+    },
+  );
+}
+
+export class Envs {
+  mounts: Map<RoutePath, EnvSource[]>;
+  claims: Set<ClaimId>;
+
+  constructor(
+    mounts: Map<RoutePath, EnvSource[]> = new Map(),
+    claims: Set<ClaimId> = new Set(),
+  ) {
+    this.mounts = mounts;
+    this.claims = claims;
+  }
+
+  mount(path: readonly string[], sources: readonly EnvSource[]): Envs {
+    if (sources.length === 0) {
+      return this;
+    }
+    let id = routeId(path);
+
+    return new Envs(
+      new Map([...this.mounts.entries(), [
+        id,
+        (this.mounts.get(id) ?? []).concat(sources),
+      ]]),
+      this.claims,
+    );
+  }
+
+  claim(
+    { route, address, key = envKey([...route, ...address]) }: EnvClaimOptions,
+  ): EnvClaim {
+    let id = claimId([...route, ...address]);
+    let nope: EnvClaim = { result: { exists: false }, rest: this };
+    if (this.claims.has(id)) {
+      return nope;
+    }
+
+    for (let end = route.length; end >= 0; end--) {
+      let mount = routeId(route.slice(0, end));
+      let sources = this.mounts.get(mount) ?? [];
+
+      for (let { name, value } of sources) {
+        if (!Object.hasOwn(value, key) || typeof value[key] === "undefined") {
+          continue;
+        }
+
+        let rest = new Envs(this.mounts, new Set([...this.claims, id]));
+        return {
+          result: {
+            exists: true,
+            value: {
+              source: name,
+              address,
+              key,
+              value: value[key],
+            },
+          },
+          rest,
+        };
+      }
+    }
+
+    return nope;
+  }
+}
+
+type ClaimId = string;
+
+function routeId(path: readonly string[]): RoutePath {
+  return `/${path.join("/")}`;
+}
+
+function claimId(address: readonly string[]): ClaimId {
+  return JSON.stringify(address);
+}
+
+function envKey(address: readonly string[]): string {
+  return address.map(normalize).filter(Boolean).join("_");
+}
+
+function normalize(value: string): string {
+  return value
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+    .replace(/([a-z\d])([A-Z])/g, "$1_$2")
+    .replace(/[^A-Za-z\d]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .toUpperCase();
+}

package/src/lib/extend.ts

@@ -0,0 +1,12 @@
+import { brand, type Extension, type Unary } from "./pipeline.js";
+
+export function extend<const E extends readonly Unary[]>(
+  ...elements: E
+): Extension<E> {
+  return brand<Extension<E>>((start: unknown): unknown =>
+    elements.reduce<unknown>(
+      (value, element) => element(value as never),
+      start,
+    )
+  );
+}

package/src/lib/maybe.ts

@@ -0,0 +1,22 @@
+export type Maybe<T> = {
+  readonly exists: false;
+} | {
+  readonly exists: true;
+  readonly value: T;
+};
+
+export function Just(): Maybe<void>;
+export function Just<T>(value: T): Maybe<T>;
+export function Just<T>(value?: T): Maybe<T | undefined> {
+  if (typeof value === "undefined") {
+    return { exists: true } as Maybe<T>;
+  } else {
+    return { exists: true, value };
+  }
+}
+
+export function Nothing<T = void>(): Maybe<T> {
+  return nothing as Maybe<T>;
+}
+
+const nothing = { exists: false };

package/src/lib/multiple.ts

@@ -0,0 +1,23 @@
+import { multiple as decode } from "./decode.js";
+import type { Param } from "./param.js";
+import { mark, type Transform, type TransformElement } from "./pipeline.js";
+
+export function multiple(): TransformElement<MultipleTransform> {
+  return mark<MultipleTransform>(
+    (param: Param<string, unknown, "one">) => ({
+      ...param,
+      cardinality: "many",
+      decode: decode(param.decode),
+    }),
+  );
+}
+
+interface MultipleTransform extends Transform {
+  readonly input: Param<string, unknown, "one">;
+  readonly output: this["input"] extends Param<
+    infer K,
+    infer Model,
+    "one"
+  > ? Param<K, Model, "many">
+    : never;
+}

package/src/lib/option.ts

@@ -0,0 +1,57 @@
+import { type AnyParam, type Param, param, type ParamModel } from "./param.js";
+import { dasherize } from "./dasherize.js";
+import {
+  brand,
+  type Check,
+  type Fold,
+  type ModelElement,
+  type Unary,
+} from "./pipeline.js";
+import { cli } from "./read.js";
+import type { AnyRoute, Definition } from "./types.js";
+
+export function option<
+  const N extends string,
+  const E extends readonly Unary[],
+>(
+  named: Definition<N>,
+  ...elements: E & Check<Zero<N>, E>
+): ElementOf<N, Fold<Zero<N>, E>> {
+  const added = elements.reduce<unknown>(
+    (value, element) => element(value as never),
+    param(named, cli([`--${dasherize(named.name)}`])),
+  ) as AnyParam;
+
+  return brand<ElementOf<N, Fold<Zero<N>, E>>>(
+    (route: AnyRoute) => {
+      let phases = [...route.phases];
+      let phase = phases.pop()!;
+      phases.push({
+        ...phase,
+        model: {
+          params: {
+            ...phase.model.params,
+            [added.name]: added,
+          },
+          steps: phase.model.steps.concat((current, bindings) => ({
+            ok: true,
+            value: {
+              ...current,
+              [added.name]: bindings[added.name],
+            },
+          })),
+        },
+      });
+      return {
+        ...route,
+        phases,
+      };
+    },
+  );
+}
+
+type Zero<N extends string> = Param<N, unknown, "one">;
+
+type ElementOf<N extends string, P> = P extends
+  Param<N, infer Model, infer _Cardinality> ? ModelElement<ParamModel<N, Model>>
+  : never;

package/src/lib/param.ts

@@ -0,0 +1,96 @@
+import { type Decoder, scalar } from "./decode.js";
+import {
+  type Check,
+  type Fold,
+  mark,
+  type ModelPatch,
+  type Transform,
+  type TransformElement,
+  type Unary,
+} from "./pipeline.js";
+import type { CLIBinding } from "./read.js";
+import type { Definition, OutputOf, Schema } from "./types.js";
+
+export interface Param<K extends string, T, C extends Cardinality>
+  extends Definition<K> {
+  schema: Schema<T>;
+  cardinality: C;
+  cli: CLIBinding;
+  decode: Decoder<Representation<C>, Decoded<C>>;
+  env?: string;
+}
+
+export type Cardinality = "one" | "many";
+
+export type AnyParam =
+  | Param<string, unknown, "one">
+  | Param<string, unknown, "many">;
+
+export type ParamModel<K extends string, V> = ModelPatch<{ [P in K]: V }>;
+
+export type Representation<C extends Cardinality> = C extends "many" ? string[]
+  : string;
+
+export function param<
+  const K extends string,
+  const E extends readonly Unary[],
+>(
+  start: Definition<K>,
+  ...elements: E & Check<ParamZero<K>, E>
+): Fold<ParamZero<K>, E> {
+  let zero: ParamZero<K> = {
+    ...start,
+    schema: unknown,
+    cardinality: "one",
+    cli: {
+      read(tokens) {
+        let claim = tokens.claimAll(() => false);
+        return {
+          result: {
+            ok: true,
+            value: { exists: false },
+            issues: [],
+          },
+          claim,
+        };
+      },
+    },
+    decode: scalar,
+  };
+
+  return elements.reduce<unknown>(
+    (value, element) => element(value as never),
+    zero,
+  ) as Fold<ParamZero<K>, E>;
+}
+
+export function schema<S extends Schema>(
+  schema: S,
+): TransformElement<SchemaTransform<OutputOf<S>>> {
+  return mark<SchemaTransform<OutputOf<S>>>(
+    (param: AnyParam) => ({
+      ...param,
+      schema,
+    }),
+  );
+}
+
+interface SchemaTransform<Output> extends Transform {
+  readonly input: AnyParam;
+  readonly output: this["input"] extends Param<infer N, unknown, infer C>
+    ? Param<N, Output, C>
+    : never;
+}
+
+const unknown: Schema<unknown> = {
+  "~standard": {
+    version: 1,
+    vendor: "@bomb.sh/router",
+    validate: (value) => ({ value }),
+  },
+};
+
+type ParamZero<K extends string> = Param<K, unknown, "one">;
+
+type Decoded<C extends Cardinality> = C extends "many" ? unknown[]
+  : unknown;