@lukoweb/apitogo 0.1.148 → 0.2.1

package/dist/declarations/cli/common/constants.d.ts

@@ -3,4 +3,3 @@ export declare const VERSION_CHECK_FILE = "version.json";
 export declare const SENTRY_DSN: undefined;
 export declare const MAX_WAIT_PENDING_TIME_MS = 1000;
 export declare const POST_HOG_CAPTURE_KEY: undefined;
-export declare const DEPLOY_SERVER_API_KEY = "qRVLTP22TFStdN6";

package/dist/declarations/cli/platform/client/platform-api.d.ts

@@ -318,6 +318,13 @@ export interface PageFileDto {
     isFile: boolean;
     order: number;
 }
+export interface StaticWebSiteDeploymentDto {
+    projectId: string;
+    environment: string;
+    byteSize: number;
+    deployServerStatus: number;
+    message?: string | null;
+}
 export interface DeployConfigDto {
     envVars: Record<string, string>;
     dockerRun: string;
@@ -380,6 +387,7 @@ export declare class PlatformApiClient {
     getAzureInfrastructureDeployStatus(projectId: string, jobId: string): Promise<DeployStatusResponse>;
     listProvisioningJobs(projectId: string): Promise<ProvisioningJobListResponse>;
     getDeploymentToken(projectId: string, regenerate?: boolean): Promise<DeploymentTokenResponse>;
+    uploadStaticWebDeployment(projectId: string, archivePath: string, env?: string): Promise<StaticWebSiteDeploymentDto>;
     getCustomDomain(projectId: string): Promise<UserCustomDomainResponse>;
     setCustomDomain(projectId: string, body: SetUserCustomDomainRequest): Promise<UserCustomDomainResponse>;
     deleteCustomDomain(projectId: string): Promise<void>;

package/dist/declarations/cli/platform/config.d.ts

@@ -3,19 +3,9 @@ export interface ApitogoConfig {
     apiKeyId: string;
     apiSecret: string;
     defaultProjectId?: string;
-    devPortalDeployUrl: string;
-    devPortalDeployApiKey: string;
-    devPortalDeployEnv: string;
     docToolPath?: string;
     createApitogoPackage: string;
 }
-export interface DevPortalDeployConfig {
-    endpointUrl: string;
-    apiKey: string;
-    defaultEnv: string;
-}
 export declare const DEFAULT_API_URL = "https://api.apitogo.com";
 export declare function loadConfig(): ApitogoConfig;
 export declare function resolveProjectId(explicit?: string, config?: ApitogoConfig): string;
-export declare function resolveDevPortalDeployConfig(config: ApitogoConfig): DevPortalDeployConfig;
-export declare const resolveDocDeployConfig: typeof resolveDevPortalDeployConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lukoweb/apitogo",
-  "version": "0.1.148",
+  "version": "0.2.1",
   "type": "module",
   "sideEffects": [
     "**/*.css",
@@ -181,6 +181,9 @@
     "@apidevtools/json-schema-ref-parser": "15.3.1",
     "@apidevtools/swagger-parser": "^12.1.0",
     "@envelop/core": "5.5.1",
+    "@fontsource/ibm-plex-sans": "^5.3.0",
+    "@fontsource/jetbrains-mono": "^5.3.0",
+    "@fontsource/space-grotesk": "^5.3.0",
     "@graphql-typed-document-node/core": "3.2.0",
     "@hono/node-server": "1.19.11",
     "@lekoarts/rehype-meta-as-attributes": "3.0.3",

package/src/app/main.tsx

@@ -65,7 +65,6 @@ export const convertApitogoConfigToOptions = (
     },
     slots: { ...configuredModulesSlots, ...config.slots },
     metadata: {
-      favicon: "https://cdn.zudoku.dev/logos/favicon.svg",
       applicationName: siteTitle,
       defaultTitle: siteTitle,
       title: `%s - ${siteTitle}`,

package/src/config/v2/__fixtures__/scenario-a-docs-only.json

@@ -0,0 +1,6 @@
+{
+  "version": 2,
+  "layout": "standalone",
+  "project": { "name": "my-docs" },
+  "portal": { "name": "My Docs" }
+}

package/src/config/v2/__fixtures__/scenario-b-managed-origin.json

@@ -0,0 +1,14 @@
+{
+  "version": 2,
+  "layout": "embedded",
+  "gateway": {
+    "origin": {
+      "mode": "managed",
+      "source": ".",
+      "runtime": "nodejs",
+      "runtimeVersion": "NODE_22_LTS",
+      "exclude": ["apitogo/**", "node_modules/**"]
+    },
+    "specs": ["openapi.yaml"]
+  }
+}

package/src/config/v2/__fixtures__/scenario-c-proxy-oidc.json

@@ -0,0 +1,15 @@
+{
+  "version": 2,
+  "layout": "standalone",
+  "gateway": {
+    "origin": { "mode": "proxy", "url": "https://api.acme.com" },
+    "specs": ["apis/openapi.yaml"],
+    "auth": {
+      "mode": "oidc",
+      "metadataUrl": "https://idp.acme.com/.well-known/openid-configuration",
+      "issuers": ["https://idp.acme.com/"],
+      "audiences": ["api://acme-orders"]
+    },
+    "policies": { "rateLimit": { "calls": 60, "periodSeconds": 60 } }
+  }
+}

package/src/config/v2/__fixtures__/scenario-h-full-stack.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://apitogo.com/schema/config-v2.json",
+  "version": 2,
+  "layout": "embedded",
+  "project": { "id": "prj_123", "name": "acme-orders" },
+  "gateway": {
+    "origin": {
+      "mode": "managed",
+      "source": "server",
+      "runtime": "nodejs",
+      "runtimeVersion": "NODE_22_LTS"
+    },
+    "specs": ["server/docs/swagger.yaml"],
+    "auth": { "mode": "identity" }
+  },
+  "identity": { "native": true },
+  "plans": {
+    "billing": {
+      "provider": "stripe",
+      "apiKey": "secret:STRIPE_API_KEY",
+      "webhookSecret": "secret:STRIPE_WEBHOOK_SECRET"
+    }
+  },
+  "portal": {
+    "name": "Acme Orders",
+    "docs": { "content": ["docs/**/*.{md,mdx}"] }
+  }
+}

package/src/config/v2/errors.ts

@@ -0,0 +1,42 @@
+import { ApitogoError } from "../../lib/util/invariant.js";
+
+/**
+ * One problem in a config file. `code` is stable and safe to match on, `path` is the dotted config path
+ * (for example `gateway.origin.mode`), `hint` says how to fix it.
+ */
+export type ConfigIssue = {
+  code: string;
+  path: string;
+  message: string;
+  hint?: string;
+};
+
+export function formatConfigIssue(issue: ConfigIssue): string {
+  const hint = issue.hint ? ` ${issue.hint}` : "";
+  const rest = issue.message.slice(issue.path.length);
+  // Several documented messages already begin with their own path; do not print it twice.
+  const startsWithPath =
+    issue.path !== "" &&
+    issue.message.startsWith(issue.path) &&
+    (rest === "" || /^[\s:]/.test(rest));
+  const text = startsWithPath
+    ? issue.message
+    : `${issue.path === "" ? "(root)" : issue.path}: ${issue.message}`;
+  return `${text}${hint} [${issue.code}]`;
+}
+
+/** Thrown when an `apitogo.config.json` cannot be loaded. Carries every problem found, not just the first. */
+export class ConfigError extends ApitogoError {
+  public readonly issues: readonly ConfigIssue[];
+
+  constructor(file: string, issues: readonly ConfigIssue[]) {
+    super(
+      `${file} has ${issues.length} problem${issues.length === 1 ? "" : "s"}:\n${issues
+        .map((issue) => `  - ${formatConfigIssue(issue)}`)
+        .join("\n")}`,
+      { title: "Invalid apitogo config" },
+    );
+    this.name = "ConfigError";
+    this.issues = issues;
+  }
+}

package/src/config/v2/index.ts

@@ -0,0 +1,105 @@
+export { ConfigError, type ConfigIssue, formatConfigIssue } from "./errors.js";
+export {
+  applyInitPlan,
+  formatInitPlan,
+  InitError,
+  type InitOptions,
+  type InitPlan,
+  type InitResult,
+  type PlannedEntry,
+  planInit,
+} from "./init.js";
+export {
+  type DocsCandidate,
+  detectExistingDocs,
+  detectLayout,
+  ensureStateDir,
+  type LayoutDetection,
+} from "./layout.js";
+export { type LoadedConfigV2, loadConfigV2 } from "./load.js";
+export {
+  BUILD_DIR,
+  GENERATED_DIR,
+  layoutRoot,
+  STATE_FILE,
+  type StatePaths,
+  stateDirFor,
+  statePathsFor,
+} from "./paths.js";
+export { parseConfigV2 } from "./parse.js";
+export {
+  type CheckContext,
+  type CheckReport,
+  checkConfigV2,
+  collectSecretRefs,
+} from "./rules.js";
+export {
+  type ResolvedConfigV2,
+  type ResolvedGateway,
+  type ResolvedIdentity,
+  type ResolvedPlans,
+  type ResolvedPortal,
+  resolveConfigV2,
+} from "./resolve.js";
+export {
+  CONFIG_VERSION,
+  type ConfigV2,
+  ConfigV2Schema,
+  type Layout,
+} from "./schema.js";
+export { type PortalProfile, portalProfile } from "./portal-profile.js";
+export {
+  hasCapability,
+  type ManifestServiceName,
+  missingManifestServices,
+  parseManifest,
+  readManifest,
+  requiredServices,
+  SUPPORTED_MANIFEST_SCHEMA,
+  type ServiceManifest,
+  serviceReady,
+  stubManifest,
+  withPortalEntry,
+  writeManifest,
+} from "./manifest.js";
+export { MANIFEST_FILE, manifestPathFor } from "./paths.js";
+export {
+  consoleLinks,
+  planPortal,
+  publishedManifest,
+  type PortalPlan,
+  type PreparedPortal,
+  type PrepareMode,
+  preparePortal,
+  renderWrapper,
+  requiredPackages,
+  WRAPPER_FILE,
+} from "./wrapper.js";
+export { materializeWorkspace, portalArtifactHash } from "./workspace.js";
+export {
+  type AddOptions,
+  applyServiceEdit,
+  formatServiceEdit,
+  isServiceName,
+  planAddService,
+  planRemoveService,
+  SERVICES,
+  ServiceEditError,
+  setProjectId,
+  type ServiceEdit,
+  type ServiceName,
+} from "./services.js";
+export { checkDependencies } from "./rules.js";
+export {
+  emptyLedger,
+  type Ledger,
+  LEDGER_VERSION,
+  LedgerError,
+  type PipelineStep,
+  readLedger,
+  runPipeline,
+  type StepOutcome,
+  type StepRecord,
+  stepOf,
+  writeLedger,
+} from "./ledger.js";

package/src/config/v2/init.ts

@@ -0,0 +1,273 @@
+import { access, mkdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { ApitogoError } from "../../lib/util/invariant.js";
+import { APITOGO_CONFIG_FILENAME } from "../apitogo-config-core.js";
+import {
+  type DocsCandidate,
+  detectExistingDocs,
+  detectLayout,
+  ensureStateDir,
+} from "./layout.js";
+import { parseConfigV2 } from "./parse.js";
+import { layoutRoot, statePathsFor } from "./paths.js";
+import type { ConfigV2, Layout } from "./schema.js";
+
+export class InitError extends ApitogoError {
+  constructor(message: string, developerHint?: string) {
+    super(message, { developerHint, title: "Cannot initialise the project" });
+    this.name = "InitError";
+  }
+}
+
+export type InitOptions = {
+  /** Project directory; created if it does not exist. */
+  dir: string;
+  /** Overrides layout detection. */
+  layout?: Layout;
+  /** Project and portal name; defaults to the directory name. */
+  name?: string;
+  /** Existing docs to include, as paths relative to `dir`; `false` skips docs detection. */
+  docs?: string[] | false;
+  /** When several docs candidates exist, include all of them instead of asking. */
+  acceptAllDocs?: boolean;
+  /** Replace an existing `apitogo.config.json`. It is the only existing file `init` ever replaces. */
+  force?: boolean;
+};
+
+export type PlannedEntry = {
+  kind: "dir" | "file";
+  /** Absolute path. */
+  path: string;
+  /** `state` entries are created by {@link ensureStateDir}. */
+  purpose: "config" | "state" | "portal";
+  content?: string;
+};
+
+export type InitPlan = {
+  dir: string;
+  configPath: string;
+  layout: Layout;
+  layoutSource: "detected" | "flag";
+  layoutReason: string;
+  /** The config that will be written; already validated against the v2 schema. */
+  config: ConfigV2;
+  docsCandidates: DocsCandidate[];
+  /** Globs written to `portal.docs.content`. */
+  docsIncluded: string[];
+  /** Several candidates were found and none was chosen yet: the caller should ask and plan again. */
+  needsDocsChoice: boolean;
+  /** Everything `init` will create. */
+  entries: PlannedEntry[];
+  /** Files that already exist and stay untouched. */
+  keep: string[];
+  /** An existing config will be replaced (only with `force`). */
+  replacesConfig: boolean;
+};
+
+async function exists(target: string): Promise<boolean> {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function starterPage(name: string): string {
+  return `---
+title: Welcome
+---
+
+# ${name}
+
+This page was created by \`apitogo init\`. Edit it, and add more \`.md\` or \`.mdx\` files next to it: each one becomes a page of your portal.
+`;
+}
+
+/** Turns paths the user named into globs, checking that each exists inside the project. */
+export async function docsFromPaths(
+  dir: string,
+  requested: readonly string[],
+): Promise<string[]> {
+  const globs: string[] = [];
+  for (const requestedPath of requested) {
+    const absolute = path.resolve(dir, requestedPath);
+    const relative = path.relative(dir, absolute).split(path.sep).join("/");
+    if (
+      relative === "" ||
+      relative.startsWith("..") ||
+      path.isAbsolute(relative)
+    ) {
+      throw new InitError(
+        `Docs path "${requestedPath}" is outside the project directory.`,
+      );
+    }
+    const info = await stat(absolute).catch(() => undefined);
+    if (!info)
+      throw new InitError(
+        `Docs path "${requestedPath}" does not exist in ${dir}.`,
+      );
+    globs.push(info.isDirectory() ? `${relative}/**/*.{md,mdx}` : relative);
+  }
+  return globs;
+}
+
+/**
+ * Decides what `init` would do without touching the disk (Reference, section 1.2). Existing files are never moved,
+ * renamed or modified; existing docs are referenced in place; the root `.gitignore` is never edited.
+ */
+export async function planInit(options: InitOptions): Promise<InitPlan> {
+  const dir = path.resolve(options.dir);
+  const configPath = path.join(dir, APITOGO_CONFIG_FILENAME);
+
+  const replacesConfig = await exists(configPath);
+  if (replacesConfig && !options.force) {
+    throw new InitError(
+      `${configPath} already exists.`,
+      "Pass --force to replace it. Nothing else in the project is changed.",
+    );
+  }
+
+  const detection = options.layout ? undefined : await detectLayout(dir);
+  const layout = options.layout ?? detection?.layout ?? "standalone";
+  const layoutReason = options.layout
+    ? `chosen with --layout ${options.layout}`
+    : (detection?.reason ?? "");
+
+  let docsCandidates: DocsCandidate[] = [];
+  let docsIncluded: string[] = [];
+  let needsDocsChoice = false;
+  if (Array.isArray(options.docs) && options.docs.length > 0) {
+    docsIncluded = await docsFromPaths(dir, options.docs);
+  } else if (options.docs !== false) {
+    docsCandidates = await detectExistingDocs(dir);
+    if (
+      docsCandidates.length === 1 ||
+      (docsCandidates.length > 1 && options.acceptAllDocs)
+    ) {
+      docsIncluded = docsCandidates.map((candidate) => candidate.glob);
+    } else if (docsCandidates.length > 1) {
+      needsDocsChoice = true;
+    }
+  }
+
+  const name = options.name?.trim() || path.basename(dir);
+  const config = parseConfigV2({
+    version: 2,
+    layout,
+    project: { name },
+    portal: {
+      name,
+      ...(docsIncluded.length > 0 ? { docs: { content: docsIncluded } } : {}),
+    },
+  });
+
+  const root = layoutRoot(dir, layout);
+  const state = statePathsFor(dir, layout);
+  const entries: PlannedEntry[] = [
+    {
+      kind: "file",
+      path: configPath,
+      purpose: "config",
+      content: `${JSON.stringify(config, null, 2)}\n`,
+    },
+    { kind: "file", path: state.gitignore, purpose: "state", content: "*\n" },
+    { kind: "dir", path: state.generatedDir, purpose: "state" },
+    { kind: "dir", path: state.buildDir, purpose: "state" },
+  ];
+
+  const keep: string[] = [];
+  if (docsIncluded.length === 0) {
+    // No existing docs to reference: give the portal an empty pages folder with one starter page.
+    const starter = path.join(root, "portal", "pages", "index.mdx");
+    if (await exists(starter)) keep.push(starter);
+    else
+      entries.push({
+        kind: "file",
+        path: starter,
+        purpose: "portal",
+        content: starterPage(name),
+      });
+  }
+
+  return {
+    dir,
+    configPath,
+    layout,
+    layoutSource: options.layout ? "flag" : "detected",
+    layoutReason,
+    config,
+    docsCandidates,
+    docsIncluded,
+    needsDocsChoice,
+    entries,
+    keep,
+    replacesConfig,
+  };
+}
+
+export type InitResult = {
+  created: string[];
+  kept: string[];
+};
+
+/** Writes the plan. Existing files are skipped, except the config when the plan replaces it. */
+export async function applyInitPlan(plan: InitPlan): Promise<InitResult> {
+  const created: string[] = [];
+  const kept = [...plan.keep];
+
+  await mkdir(plan.dir, { recursive: true });
+  await ensureStateDir(statePathsFor(plan.dir, plan.layout));
+  for (const entry of plan.entries.filter((e) => e.purpose === "state"))
+    created.push(entry.path);
+
+  for (const entry of plan.entries.filter((e) => e.purpose !== "state")) {
+    if (entry.kind === "dir") {
+      await mkdir(entry.path, { recursive: true });
+      created.push(entry.path);
+      continue;
+    }
+    await mkdir(path.dirname(entry.path), { recursive: true });
+    try {
+      await writeFile(entry.path, entry.content ?? "", {
+        flag: entry.purpose === "config" && plan.replacesConfig ? "w" : "wx",
+      });
+      created.push(entry.path);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      kept.push(entry.path);
+    }
+  }
+
+  return { created, kept };
+}
+
+/** The "will create" list shown before anything is written. */
+export function formatInitPlan(plan: InitPlan): string[] {
+  const rel = (target: string) =>
+    path.relative(plan.dir, target).split(path.sep).join("/") || ".";
+  const lines = [
+    `Layout: ${plan.layout} (${plan.layoutReason})`,
+    plan.docsIncluded.length > 0
+      ? `Existing docs are used in place: ${plan.docsIncluded.join(", ")}`
+      : "No existing docs found: a starter page is created.",
+    "Will create:",
+    ...plan.entries
+      .filter((entry) => !(entry.kind === "dir" && entry.purpose === "state"))
+      .map(
+        (entry) =>
+          `  ${rel(entry.path)}${plan.replacesConfig && entry.purpose === "config" ? " (replaces the existing file)" : ""}`,
+      ),
+    `  ${rel(statePathsFor(plan.dir, plan.layout).dir)}/generated/ and build/ (generated state, ignored by git)`,
+  ];
+  if (plan.keep.length > 0) {
+    lines.push(
+      "Will keep as they are:",
+      ...plan.keep.map((target) => `  ${rel(target)}`),
+    );
+  }
+  lines.push(
+    "Your own files are never moved, renamed or edited, and your .gitignore is left alone.",
+  );
+  return lines;
+}