@wirebench/engine 2.1.1

package/dist/project/keystores.js

@@ -0,0 +1,66 @@
+/**
+ * The bridge between the project model's loose `WssRef` (which round-trips the raw
+ * `wss/keystores.yaml` entry verbatim, so an unknown field written by a later build survives)
+ * and the typed `KeystoreDef` the keystore loaders take.
+ */
+import { ProjectError } from '../errors.js';
+import { keystoreEntrySchema } from './schema.js';
+/**
+ * Reads one keystore registry entry out of its `WssRef`.
+ *
+ * @param ref the `Project.wss.keystores` entry
+ * @returns the typed definition
+ * @throws ProjectError `keystore-entry-invalid` when the stored document is not a keystore entry
+ */
+export function toKeystoreDef(ref) {
+    const parsed = keystoreEntrySchema.safeParse(ref.document);
+    if (!parsed.success) {
+        throw new ProjectError('keystore-entry-invalid', `Keystore "${ref.name}" is missing a path or type.`, {
+            details: { id: ref.id },
+        });
+    }
+    const entry = parsed.data;
+    return {
+        id: entry.id,
+        name: entry.name,
+        path: entry.path,
+        type: entry.type,
+        ...(entry.passwordSecretRef !== undefined ? { passwordSecretRef: entry.passwordSecretRef } : {}),
+        ...(entry.passwordEnv !== undefined ? { passwordEnv: entry.passwordEnv } : {}),
+        ...(entry.defaultAlias !== undefined ? { defaultAlias: entry.defaultAlias } : {}),
+    };
+}
+/**
+ * The `WssRef` that stores `def` in `wss/keystores.yaml`, preserving any unknown fields the
+ * existing entry carried.
+ *
+ * @param def the definition to persist
+ * @param existing the entry being replaced, when this is an update
+ * @returns the ref to put into `Project.wss.keystores`
+ */
+export function toKeystoreRef(def, existing) {
+    const document = { ...existing?.document };
+    document['id'] = def.id;
+    document['name'] = def.name;
+    document['path'] = def.path;
+    document['type'] = def.type;
+    if (def.passwordSecretRef === undefined) {
+        delete document['passwordSecretRef'];
+    }
+    else {
+        document['passwordSecretRef'] = def.passwordSecretRef;
+    }
+    if (def.passwordEnv === undefined) {
+        delete document['passwordEnv'];
+    }
+    else {
+        document['passwordEnv'] = def.passwordEnv;
+    }
+    if (def.defaultAlias === undefined) {
+        delete document['defaultAlias'];
+    }
+    else {
+        document['defaultAlias'] = def.defaultAlias;
+    }
+    return { id: def.id, name: def.name, document };
+}

package/dist/project/load.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Reads a project folder back into a {@link Project}.
+ *
+ * The folder is the source of truth for names and ordering: an interface is a
+ * directory containing `interface.yaml`, a request is a `*.request.yaml` plus
+ * its sibling `.xml`, and each entity's `slug` comes from its file name. Every
+ * recoverable inconsistency (an orphaned envelope, an operation folder no
+ * interface declares) becomes a {@link ProjectProblem} rather than an error, so
+ * a slightly damaged project still opens.
+ */
+import type { Project } from './model.js';
+import type { FsLike } from './fs.js';
+/** A recoverable inconsistency found while loading a project. */
+export interface ProjectProblem {
+    readonly code: 'missing-envelope' | 'orphan-operation-folder' | 'orphan-request-file' | 'missing-interface-file'
+    /** An `apis/<slug>/` directory with no `api.yaml`; the API is skipped. */
+     | 'missing-api-file'
+    /** A raw body whose sibling file is gone; the request loads with an empty body. */
+     | 'missing-body'
+    /** A folder nested deeper than {@link MAX_FOLDER_DEPTH}; it and everything below it is skipped. */
+     | 'folder-too-deep'
+    /** An API and an interface sharing a slug, which would make an endpoint override ambiguous. */
+     | 'api-slug-conflict';
+    readonly message: string;
+    /** Path relative to the project root. */
+    readonly file: string;
+}
+/** The result of {@link loadProject}: the model plus anything odd about the folder. */
+export interface LoadResult {
+    readonly project: Project;
+    readonly problems: readonly ProjectProblem[];
+}
+/** Options for {@link loadProject}. */
+export interface LoadProjectOptions {
+    readonly fs?: FsLike;
+}
+/**
+ * Loads the project stored in the directory `root`.
+ *
+ * @throws ProjectError `project-not-found` when there is no `wirebench.yaml`,
+ * `project-format-too-new` for a newer format version, `project-file-invalid`
+ * for malformed or schema-violating YAML (with the offending file in `details`).
+ */
+export declare function loadProject(root: string, options?: LoadProjectOptions): Promise<LoadResult>;