@lukoweb/apitogo 0.1.148 → 0.2.1

package/src/config/v2/resolve.ts

@@ -0,0 +1,186 @@
+import path from "node:path";
+import { layoutRoot, type StatePaths, statePathsFor } from "./paths.js";
+import type { ConfigV2, Layout } from "./schema.js";
+
+export { layoutRoot };
+
+/** A path relative to the config file, made absolute. A leading `!` (negated glob) is preserved. */
+function fromConfig(configDir: string, value: string): string {
+  return value.startsWith("!")
+    ? `!${path.resolve(configDir, value.slice(1))}`
+    : path.resolve(configDir, value);
+}
+
+export type ResolvedPortal = {
+  enabled: boolean;
+  dir: string;
+  name: string;
+  docs: {
+    enabled: boolean;
+    provider: "apitogo" | "external";
+    /** Absolute globs. Empty for an external docs provider. */
+    content: string[];
+    url?: string;
+  };
+  console: { enabled: boolean };
+  theme: string;
+  requireAuth: boolean | { exclude: string[] };
+  search: "pagefind" | "inkeep" | "none";
+};
+
+export type ResolvedGateway = {
+  enabled: boolean;
+  provider: string;
+  origin: NonNullable<ConfigV2["gateway"]>["origin"];
+  /** Absolute paths. */
+  specs: string[];
+  auth?: NonNullable<ConfigV2["gateway"]>["auth"];
+  policies: NonNullable<NonNullable<ConfigV2["gateway"]>["policies"]>;
+};
+
+export type ResolvedIdentity = {
+  enabled: boolean;
+  provider: "apitogo" | "oidc";
+  native: boolean;
+  connections: NonNullable<NonNullable<ConfigV2["identity"]>["connections"]>;
+  clients: NonNullable<NonNullable<ConfigV2["identity"]>["clients"]>;
+  issuer?: string;
+  clientId?: string;
+  providerOptions: NonNullable<
+    NonNullable<ConfigV2["identity"]>["providerOptions"]
+  >;
+};
+
+export type ResolvedPlans = {
+  enabled: boolean;
+  /** Absolute path of the plan catalog. */
+  file: string;
+  billing: {
+    provider: "stripe" | "none";
+    apiKey?: string;
+    webhookSecret?: string;
+    successUrl?: string;
+    cancelUrl?: string;
+  };
+};
+
+export type ResolvedConfigV2 = {
+  configPath: string;
+  configDir: string;
+  layout: Layout;
+  /** `<root>` of the layout: where `portal/`, `plans.json` and `apis/` live by default. */
+  root: string;
+  /** Default folder for OpenAPI files created by `init`. */
+  apisDir: string;
+  /** Generated and observed state (`state.json`, `generated/`, `build/`), ignored by git on its own. */
+  state: StatePaths;
+  project: { id?: string; name: string };
+  portal?: ResolvedPortal;
+  gateway?: ResolvedGateway;
+  identity?: ResolvedIdentity;
+  plans?: ResolvedPlans;
+};
+
+/**
+ * Applies the documented defaults and makes every path absolute. Defaults for `portal.dir`, `plans.file`
+ * and the spec folder derive from `<root>`, so a standalone config can omit them. A section that is present
+ * without `enabled` is enabled.
+ */
+export function resolveConfigV2(
+  config: ConfigV2,
+  configPath: string,
+): ResolvedConfigV2 {
+  const absoluteConfigPath = path.resolve(configPath);
+  const configDir = path.dirname(absoluteConfigPath);
+  const layout = config.layout ?? "standalone";
+  const root = layoutRoot(configDir, layout);
+  const projectName = config.project?.name ?? path.basename(configDir);
+
+  const resolved: ResolvedConfigV2 = {
+    configPath: absoluteConfigPath,
+    configDir,
+    layout,
+    root,
+    apisDir: path.join(root, "apis"),
+    state: statePathsFor(configDir, layout),
+    project: { id: config.project?.id, name: projectName },
+  };
+
+  const { portal, gateway, identity, plans } = config;
+
+  if (portal) {
+    const dir = portal.dir
+      ? path.resolve(configDir, portal.dir)
+      : path.join(root, "portal");
+    const provider = portal.docs?.provider ?? "apitogo";
+    resolved.portal = {
+      enabled: portal.enabled ?? true,
+      dir,
+      name: portal.name ?? projectName,
+      docs: {
+        enabled: portal.docs?.enabled ?? true,
+        provider,
+        content:
+          provider === "external"
+            ? []
+            : portal.docs?.content
+              ? portal.docs.content.map((glob) => fromConfig(configDir, glob))
+              : [path.join(dir, "pages", "**", "*.{md,mdx}")],
+        url: portal.docs?.url,
+      },
+      console: { enabled: portal.console?.enabled ?? true },
+      theme: portal.theme
+        ? path.resolve(configDir, portal.theme)
+        : path.join(dir, "theme.json"),
+      requireAuth: portal.requireAuth ?? false,
+      search: provider === "external" ? "none" : (portal.search ?? "pagefind"),
+    };
+  }
+
+  if (gateway) {
+    resolved.gateway = {
+      enabled: gateway.enabled ?? true,
+      provider: gateway.provider ?? "apitogo",
+      origin: {
+        ...gateway.origin,
+        source: gateway.origin.source
+          ? path.resolve(configDir, gateway.origin.source)
+          : undefined,
+      },
+      specs: gateway.specs.map((spec) => path.resolve(configDir, spec)),
+      auth: gateway.auth,
+      policies: gateway.policies ?? {},
+    };
+  }
+
+  if (identity) {
+    resolved.identity = {
+      enabled: identity.enabled ?? true,
+      provider: identity.provider ?? "apitogo",
+      native: identity.native ?? true,
+      connections: identity.connections ?? [],
+      clients: identity.clients ?? [],
+      issuer: identity.issuer,
+      clientId: identity.clientId,
+      providerOptions: identity.providerOptions ?? {},
+    };
+  }
+
+  if (plans) {
+    resolved.plans = {
+      enabled: plans.enabled ?? true,
+      file: plans.file
+        ? path.resolve(configDir, plans.file)
+        : path.join(root, "plans.json"),
+      billing: {
+        provider: plans.billing?.provider ?? "stripe",
+        apiKey: plans.billing?.apiKey,
+        webhookSecret: plans.billing?.webhookSecret,
+        successUrl: plans.billing?.successUrl,
+        cancelUrl: plans.billing?.cancelUrl,
+      },
+    };
+  }
+
+  return resolved;
+}