typespun-codegen 0.0.7 → 0.0.9

package/dist/project/config.js

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import ts from 'typescript';
+import { discoverDefaultsPath, discoverInputPath, findNearestTsconfig, } from './discovery.js';
+const OUTPUT_EXTENSIONS = new Set(['.ts', '.mts', '.cts']);
+const UNKNOWN_KEYS_POLICIES = new Set([
+    'error',
+    'warn',
+    'ignore',
+]);
+const SECRET_DEFAULTS_POLICIES = new Set([
+    'warn',
+    'allow',
+    'error',
+]);
+export class ProjectConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectConfigError';
+    }
+}
+export function loadProjectConfig(options) {
+    const projectDirectory = resolve(options.projectDirectory);
+    const configPath = options.configPath
+        ? resolve(projectDirectory, options.configPath)
+        : resolve(projectDirectory, 'typespun.json');
+    const hasConfig = options.configPath !== undefined || existsSync(configPath);
+    const config = hasConfig ? readProjectConfig(configPath) : {};
+    const configDirectory = hasConfig ? dirname(configPath) : projectDirectory;
+    const inputPath = config.input
+        ? resolve(configDirectory, config.input)
+        : discoverInputPath(configDirectory);
+    validateInputExtension(inputPath);
+    const outputPath = config.output
+        ? resolve(configDirectory, config.output)
+        : resolve(configDirectory, `src/generated/typespun${extname(inputPath)}`);
+    validateOutputExtension(outputPath);
+    const tsconfigPath = config.tsconfig
+        ? resolve(configDirectory, config.tsconfig)
+        : findNearestTsconfig(inputPath);
+    if (tsconfigPath === undefined) {
+        throw new Error(`Could not find tsconfig.json for ${inputPath}`);
+    }
+    const defaults = resolveDefaults(config.defaults, configDirectory);
+    const envPrefix = config.envPrefix?.replace(/_+$/, '');
+    return {
+        configDirectory,
+        inputPath,
+        outputPath,
+        tsconfigPath,
+        ...(defaults.path === undefined ? {} : { defaultsPath: defaults.path }),
+        ...(envPrefix === undefined ? {} : { envPrefix }),
+        unknownKeys: defaults.unknownKeys,
+        secretDefaults: config.secretDefaults ?? 'warn',
+    };
+}
+function readProjectConfig(path) {
+    let value;
+    try {
+        const parsed = ts.parseConfigFileTextToJson(path, readFileSync(path, 'utf8'));
+        if (parsed.error !== undefined)
+            throw new Error('invalid JSON');
+        value = parsed.config;
+    }
+    catch {
+        throw new ProjectConfigError('Could not parse typespun.json as JSON with comments');
+    }
+    if (!isRecord(value)) {
+        throw new ProjectConfigError('typespun.json must contain an object');
+    }
+    rejectUnknownKeys(value, ['input', 'output', 'tsconfig', 'envPrefix', 'defaults', 'secretDefaults'], 'typespun.json');
+    assertOptionalString(value, 'input', 'typespun.json.input');
+    assertOptionalString(value, 'output', 'typespun.json.output');
+    assertOptionalString(value, 'tsconfig', 'typespun.json.tsconfig');
+    assertOptionalString(value, 'envPrefix', 'typespun.json.envPrefix');
+    assertSecretDefaultsPolicy(value.secretDefaults);
+    if (value.defaults !== undefined) {
+        validateDefaultsConfig(value.defaults);
+    }
+    return value;
+}
+function validateDefaultsConfig(value) {
+    if (typeof value === 'string') {
+        return;
+    }
+    if (!isRecord(value)) {
+        throw new ProjectConfigError('typespun.json.defaults must be a string or object');
+    }
+    rejectUnknownKeys(value, ['path', 'unknownKeys'], 'defaults');
+    assertOptionalString(value, 'path', 'typespun.json.defaults.path');
+    assertUnknownKeysPolicy(value.unknownKeys);
+}
+function resolveDefaults(defaults, configDirectory) {
+    if (typeof defaults === 'string') {
+        return { path: resolve(configDirectory, defaults), unknownKeys: 'error' };
+    }
+    if (defaults?.path !== undefined) {
+        return {
+            path: resolve(configDirectory, defaults.path),
+            unknownKeys: defaults.unknownKeys ?? 'error',
+        };
+    }
+    const path = discoverDefaultsPath(configDirectory);
+    return path === undefined
+        ? { unknownKeys: defaults?.unknownKeys ?? 'error' }
+        : { path, unknownKeys: defaults?.unknownKeys ?? 'error' };
+}
+function rejectUnknownKeys(value, allowedKeys, context) {
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.includes(key)) {
+            throw new ProjectConfigError(`Unknown ${context} key: ${key}`);
+        }
+    }
+}
+function assertOptionalString(value, key, context) {
+    if (value[key] !== undefined && typeof value[key] !== 'string') {
+        throw new ProjectConfigError(`${context} must be a string`);
+    }
+}
+function assertUnknownKeysPolicy(value) {
+    if (value !== undefined &&
+        !UNKNOWN_KEYS_POLICIES.has(value)) {
+        throw new ProjectConfigError('typespun.json.defaults.unknownKeys must be error, warn, or ignore');
+    }
+}
+function assertSecretDefaultsPolicy(value) {
+    if (value !== undefined &&
+        !SECRET_DEFAULTS_POLICIES.has(value)) {
+        throw new ProjectConfigError('typespun.json.secretDefaults must be warn, allow, or error');
+    }
+}
+function validateInputExtension(path) {
+    if (!OUTPUT_EXTENSIONS.has(extname(path))) {
+        throw new ProjectConfigError('input must use a .ts, .mts, or .cts extension');
+    }
+}
+function validateOutputExtension(path) {
+    if (!OUTPUT_EXTENSIONS.has(extname(path))) {
+        throw new ProjectConfigError('output must use a .ts, .mts, or .cts extension');
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/project/defaults.d.ts

@@ -0,0 +1,22 @@
+import type { FieldIR, SecretDefaultsPolicy, UnknownKeysPolicy } from '../contracts.js';
+export interface DefaultsDocument {
+    readonly path: string;
+    readonly content: string;
+}
+export interface CompileDefaultsPolicies {
+    readonly unknownKeys: UnknownKeysPolicy;
+    readonly secretDefaults: SecretDefaultsPolicy;
+}
+export interface DefaultsDiagnostic {
+    readonly code: 'invalid_defaults_document' | 'invalid_default_value' | 'secret_default' | 'unknown_defaults_key' | 'unsafe_defaults_key';
+    readonly path: string;
+    readonly file: string;
+    readonly message: string;
+}
+export interface CompiledDefaultsResult {
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly warnings: readonly DefaultsDiagnostic[];
+    readonly errors: readonly DefaultsDiagnostic[];
+}
+export declare function compileDefaults(document: DefaultsDocument, fields: readonly FieldIR[], policies: CompileDefaultsPolicies): CompiledDefaultsResult;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/project/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/project/defaults.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,OAAO,EACP,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;CAC/C;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EACT,2BAA2B,GAC3B,uBAAuB,GACvB,gBAAgB,GAChB,sBAAsB,GACtB,qBAAqB,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACjD,QAAQ,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAChD;AAKD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,QAAQ,EAAE,uBAAuB,GAChC,sBAAsB,CAwDxB"}

package/dist/project/defaults.js

@@ -0,0 +1,216 @@
+import { extname } from 'node:path';
+import { parseDocument } from 'yaml';
+import { validateTypedValue } from 'typespun/generated';
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const ALIAS_LIMIT = 20;
+export function compileDefaults(document, fields, policies) {
+    const warnings = [];
+    const errors = [];
+    const values = {};
+    const compiledPaths = new Set();
+    const fieldByDefaultsPath = new Map(fields.map((field) => [toPathKey(field.defaultsPath), field]));
+    const parsed = parseDefaultsDocument(document, errors);
+    if (!isRecord(parsed)) {
+        if (parsed !== undefined) {
+            errors.push(diagnostic('invalid_defaults_document', [], document.path, 'Defaults document must contain an object at its root'));
+        }
+        applyInlineDefaults(fields, compiledPaths, policies, values, warnings, errors);
+        return { values, warnings, errors };
+    }
+    collectUnsafeKeys(parsed, [], document.path, errors, new Set());
+    walkDefaults(parsed, [], fieldByDefaultsPath, fields, policies, document.path, values, warnings, errors, compiledPaths);
+    applyInlineDefaults(fields, compiledPaths, policies, values, warnings, errors);
+    return { values, warnings, errors };
+}
+function parseDefaultsDocument(document, errors) {
+    if (extname(document.path) === '.json') {
+        try {
+            return JSON.parse(document.content);
+        }
+        catch {
+            errors.push(diagnostic('invalid_defaults_document', [], document.path, 'Defaults document is not valid JSON'));
+            return undefined;
+        }
+    }
+    try {
+        const parsed = parseDocument(document.content, {
+            customTags: [],
+            merge: false,
+            prettyErrors: false,
+            resolveKnownTags: false,
+            schema: 'core',
+            stringKeys: true,
+            uniqueKeys: true,
+        });
+        if (parsed.errors.length > 0 || parsed.warnings.length > 0) {
+            errors.push(diagnostic('invalid_defaults_document', [], document.path, 'Defaults document is not valid YAML'));
+            return undefined;
+        }
+        return parsed.toJS({ maxAliasCount: ALIAS_LIMIT });
+    }
+    catch {
+        errors.push(diagnostic('invalid_defaults_document', [], document.path, 'Defaults document is not valid YAML'));
+        return undefined;
+    }
+}
+function walkDefaults(value, path, fieldByDefaultsPath, fields, policies, file, values, warnings, errors, compiledPaths) {
+    for (const [key, child] of Object.entries(value)) {
+        const childPath = [...path, key];
+        if (DANGEROUS_KEYS.has(key)) {
+            continue;
+        }
+        const field = fieldByDefaultsPath.get(toPathKey(childPath));
+        if (field !== undefined) {
+            compileField(field, child, childPath, policies, file, values, warnings, errors, compiledPaths);
+            continue;
+        }
+        if (hasDefaultsDescendant(fields, childPath)) {
+            if (!isRecord(child)) {
+                errors.push(diagnostic('invalid_default_value', childPath, file, 'Expected an object for nested defaults'));
+                continue;
+            }
+            walkDefaults(child, childPath, fieldByDefaultsPath, fields, policies, file, values, warnings, errors, compiledPaths);
+            continue;
+        }
+        reportUnknownPath(childPath, policies.unknownKeys, file, warnings, errors);
+    }
+}
+function collectUnsafeKeys(value, path, file, errors, ancestors) {
+    if (!Array.isArray(value) && !isRecord(value)) {
+        return;
+    }
+    if (ancestors.has(value)) {
+        errors.push(diagnostic('invalid_defaults_document', path, file, 'Defaults document contains a recursive alias'));
+        return;
+    }
+    ancestors.add(value);
+    if (Array.isArray(value)) {
+        for (const [index, child] of value.entries()) {
+            collectUnsafeKeys(child, [...path, String(index)], file, errors, ancestors);
+        }
+    }
+    else {
+        for (const [key, child] of Object.entries(value)) {
+            const childPath = [...path, key];
+            if (DANGEROUS_KEYS.has(key)) {
+                errors.push(diagnostic('unsafe_defaults_key', childPath, file, 'Defaults path contains an unsafe key'));
+            }
+            collectUnsafeKeys(child, childPath, file, errors, ancestors);
+        }
+    }
+    ancestors.delete(value);
+}
+function compileField(field, value, defaultsPath, policies, file, values, warnings, errors, compiledPaths) {
+    compiledPaths.add(toPathKey(field.propertyPath));
+    const validationMessage = validateTypedValue(field.kind, value);
+    if (validationMessage !== undefined) {
+        errors.push(diagnostic('invalid_default_value', defaultsPath, file, field.secret
+            ? 'Secret default does not match its declared field type'
+            : validationMessage));
+        return;
+    }
+    if (field.secret) {
+        if (policies.secretDefaults === 'error') {
+            errors.push(diagnostic('secret_default', defaultsPath, file, 'Secret fields cannot have compiled defaults'));
+            return;
+        }
+        if (policies.secretDefaults === 'warn') {
+            warnings.push(diagnostic('secret_default', defaultsPath, file, 'Secret field has a compiled default'));
+        }
+    }
+    if (!setValue(values, field.propertyPath, cloneValue(value))) {
+        errors.push(diagnostic('unsafe_defaults_key', defaultsPath, file, 'Defaults path contains an unsafe key'));
+    }
+}
+function applyInlineDefaults(fields, compiledPaths, policies, values, warnings, errors) {
+    for (const field of fields) {
+        if (!field.hasDefault ||
+            field.defaultValue === undefined ||
+            compiledPaths.has(toPathKey(field.propertyPath))) {
+            continue;
+        }
+        if (field.secret) {
+            if (policies.secretDefaults === 'error') {
+                errors.push(diagnostic('secret_default', field.defaultsPath, field.location.file, 'Secret fields cannot have inline defaults'));
+                continue;
+            }
+            if (policies.secretDefaults === 'warn') {
+                warnings.push(diagnostic('secret_default', field.defaultsPath, field.location.file, 'Secret field has an inline default'));
+            }
+        }
+        if (!setValue(values, field.propertyPath, cloneValue(field.defaultValue))) {
+            errors.push(diagnostic('unsafe_defaults_key', field.defaultsPath, field.location.file, 'Defaults path contains an unsafe key'));
+        }
+    }
+}
+function reportUnknownPath(path, policy, file, warnings, errors) {
+    if (policy === 'ignore') {
+        return;
+    }
+    const target = policy === 'warn' ? warnings : errors;
+    target.push(diagnostic('unknown_defaults_key', path, file, 'Defaults path does not match a declared field'));
+}
+function hasDefaultsDescendant(fields, path) {
+    return fields.some((field) => field.defaultsPath.length > path.length &&
+        path.every((part, index) => field.defaultsPath[index] === part));
+}
+function setValue(target, path, value) {
+    if (path.length === 0 || path.some((part) => DANGEROUS_KEYS.has(part))) {
+        return false;
+    }
+    let current = target;
+    for (const [index, part] of path.entries()) {
+        if (index === path.length - 1) {
+            Object.defineProperty(current, part, {
+                configurable: true,
+                enumerable: true,
+                value,
+                writable: true,
+            });
+            return true;
+        }
+        const existing = current[part];
+        if (isRecord(existing)) {
+            current = existing;
+            continue;
+        }
+        const next = {};
+        Object.defineProperty(current, part, {
+            configurable: true,
+            enumerable: true,
+            value: next,
+            writable: true,
+        });
+        current = next;
+    }
+    return false;
+}
+function cloneValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneValue(item));
+    }
+    if (isRecord(value)) {
+        const cloned = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (!DANGEROUS_KEYS.has(key)) {
+                Object.defineProperty(cloned, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value: cloneValue(child),
+                    writable: true,
+                });
+            }
+        }
+        return cloned;
+    }
+    return value;
+}
+function diagnostic(code, path, file, message) {
+    return { code, path: path.join('.'), file, message };
+}
+function toPathKey(path) {
+    return JSON.stringify(path);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/project/discovery.d.ts

@@ -0,0 +1,9 @@
+export declare const CONVENTIONAL_INPUTS: readonly ["src/config.ts", "src/config.mts", "src/config.cts"];
+export declare const CONVENTIONAL_DEFAULTS: readonly ["config.yaml", "config.yml", "config.json", "config/config.yaml", "config/config.yml", "config/config.json", "src/config.yaml", "src/config.yml", "src/config.json"];
+export declare class ProjectDiscoveryError extends Error {
+    constructor(message: string);
+}
+export declare function discoverInputPath(projectDirectory: string): string;
+export declare function discoverDefaultsPath(projectDirectory: string): string | undefined;
+export declare function findNearestTsconfig(inputPath: string): string | undefined;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/project/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/project/discovery.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,gEAItB,CAAC;AAEX,eAAO,MAAM,qBAAqB,gLAUxB,CAAC;AAEX,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAalE;AAED,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,GACvB,MAAM,GAAG,SAAS,CAapB;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAezE"}

package/dist/project/discovery.js

@@ -0,0 +1,66 @@
+import { existsSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export const CONVENTIONAL_INPUTS = [
+    'src/config.ts',
+    'src/config.mts',
+    'src/config.cts',
+];
+export const CONVENTIONAL_DEFAULTS = [
+    'config.yaml',
+    'config.yml',
+    'config.json',
+    'config/config.yaml',
+    'config/config.yml',
+    'config/config.json',
+    'src/config.yaml',
+    'src/config.yml',
+    'src/config.json',
+];
+export class ProjectDiscoveryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectDiscoveryError';
+    }
+}
+export function discoverInputPath(projectDirectory) {
+    const candidates = findExistingCandidates(projectDirectory, CONVENTIONAL_INPUTS);
+    if (candidates.length !== 1) {
+        throw new ProjectDiscoveryError(`Expected exactly one conventional input, found ${candidates.length}.`);
+    }
+    return candidates[0];
+}
+export function discoverDefaultsPath(projectDirectory) {
+    const candidates = findExistingCandidates(projectDirectory, CONVENTIONAL_DEFAULTS);
+    if (candidates.length > 1) {
+        throw new ProjectDiscoveryError(`Multiple conventional defaults files found: ${candidates.join(', ')}. Configure defaults.path explicitly.`);
+    }
+    return candidates[0];
+}
+export function findNearestTsconfig(inputPath) {
+    let directory = dirname(resolve(inputPath));
+    while (true) {
+        const candidate = join(directory, 'tsconfig.json');
+        if (isFile(candidate)) {
+            return candidate;
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            return undefined;
+        }
+        directory = parent;
+    }
+}
+function findExistingCandidates(projectDirectory, candidates) {
+    const root = resolve(projectDirectory);
+    return candidates
+        .map((candidate) => join(root, candidate))
+        .filter((candidate) => isFile(candidate));
+}
+function isFile(path) {
+    try {
+        return existsSync(path) && statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespun-codegen",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "TypeScript schema analyzer, generator, and CLI for Typespun",
   "license": "MIT",
   "type": "module",
@@ -29,7 +29,7 @@
     "!dist/.tsbuildinfo"
   ],
   "bin": {
-    "typespun": "dist/bin.js"
+    "typespun-codegen": "dist/bin.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "typescript": "6.0.3",
-    "typespun": "^0.0.7",
+    "typespun": "^0.0.9",
     "yaml": "2.9.1"
   }
 }