typespun-codegen 0.0.4 → 0.0.8

package/dist/project/defaults.js

@@ -1,216 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,66 +0,0 @@
-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;
-    }
-}