bdy 1.23.7-dev-target-commands → 1.23.7-dev

package/distTs/src/command/yaml/validate.js

@@ -1,259 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const path_1 = require("path");
-const utils_1 = require("../../utils");
-const output_1 = __importDefault(require("../../output"));
-const texts_1 = require("../../texts");
-const schemaUtils_1 = require("./schemaUtils");
-// Valid top-level keys the schema's PipelineYaml.properties omits (everything
-// else is derived from the schema, so this only covers genuine gaps).
-const SCHEMA_OMITTED_TOP_LEVEL_KEYS = ['git_config_ref'];
-const LABEL_KEYS = ['action', 'target', 'name', 'key', 'title', 'trigger_condition'];
-function stripRef(ref) {
-    return ref.replace('#/$defs/', '');
-}
-function prettifyKey(key) {
-    return key
-        .split('_')
-        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-        .join(' ');
-}
-function outputErrors(result, indent) {
-    for (const err of result.errors) {
-        output_1.default.muted(`${indent}${err.path}: ${err.message}`);
-    }
-}
-// Array whose items reference a def — directly, or via a single $ref branch in
-// items.oneOf (how `targets` mixes a string ref with an object form).
-function itemRef(prop) {
-    if (!prop || prop.type !== 'array' || !prop.items)
-        return null;
-    if (prop.items.$ref)
-        return stripRef(prop.items.$ref);
-    if (Array.isArray(prop.items.oneOf)) {
-        const refs = prop.items.oneOf.filter((b) => b && b.$ref);
-        if (refs.length === 1)
-            return stripRef(refs[0].$ref);
-    }
-    return null;
-}
-function classifySections(props) {
-    const itemSections = [];
-    const objectSections = [];
-    const settingsProps = {};
-    for (const [key, prop] of Object.entries(props)) {
-        const ref = itemRef(prop);
-        if (ref) {
-            itemSections.push({ key, defName: ref });
-        }
-        else if (prop && prop.$ref) {
-            objectSections.push({ key, defName: stripRef(prop.$ref) });
-        }
-        else {
-            settingsProps[key] = prop;
-        }
-    }
-    return { itemSections, objectSections, settingsProps };
-}
-function discriminatorProp(def) {
-    return def && def.oneOf && def.discriminator ? def.discriminator.propertyName : null;
-}
-// Resolve a discriminated def to its concrete branch by the item's `type`, so
-// AJV always validates against a single def (never a oneOf). Plain defs pass through.
-function resolveDef(defs, refName, value) {
-    const def = defs[refName];
-    const prop = discriminatorProp(def);
-    if (!prop)
-        return { defName: refName };
-    const dv = value?.[prop];
-    if (dv === undefined || dv === null)
-        return { missingType: prop };
-    for (const branch of def.oneOf) {
-        const branchName = branch && branch.$ref ? stripRef(branch.$ref) : null;
-        if (!branchName)
-            continue;
-        if (defs[branchName]?.properties?.[prop]?.const === dv)
-            return { defName: branchName };
-    }
-    return { unknownType: String(dv), prop };
-}
-function itemLabel(value, index, discProp) {
-    let name;
-    for (const k of LABEL_KEYS) {
-        if (value && value[k]) {
-            name = String(value[k]);
-            break;
-        }
-    }
-    if (!name && !discProp && value && value.type)
-        name = String(value.type);
-    if (!name)
-        name = `#${index + 1}`;
-    return discProp && value && value[discProp] ? `${name} (${value[discProp]})` : name;
-}
-function validateItemSection(defs, items, refName) {
-    const discProp = discriminatorProp(defs[refName]);
-    let errors = 0;
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        if (item === null || typeof item !== 'object' || Array.isArray(item)) {
-            output_1.default.green(`  ${String(item)}`);
-            continue;
-        }
-        const label = itemLabel(item, i, discProp);
-        const resolved = resolveDef(defs, refName, item);
-        if ('missingType' in resolved) {
-            output_1.default.error(`  ${label}: missing "${resolved.missingType}"`);
-            errors++;
-            continue;
-        }
-        if ('unknownType' in resolved) {
-            output_1.default.error(`  ${label}: unknown ${resolved.prop} "${resolved.unknownType}"`);
-            errors++;
-            continue;
-        }
-        const result = (0, schemaUtils_1.validateAgainstDef)(resolved.defName, item);
-        if (result.valid) {
-            output_1.default.green(`  ${label}`);
-        }
-        else {
-            errors += result.errors.length;
-            output_1.default.error(`  ${label}`);
-            outputErrors(result, '    ');
-        }
-    }
-    return errors;
-}
-function validateObjectSection(defs, label, value, refName) {
-    const resolved = resolveDef(defs, refName, value);
-    if ('missingType' in resolved) {
-        output_1.default.error(label);
-        output_1.default.muted(`  missing "${resolved.missingType}"`);
-        return 1;
-    }
-    if ('unknownType' in resolved) {
-        output_1.default.error(label);
-        output_1.default.muted(`  unknown ${resolved.prop} "${resolved.unknownType}"`);
-        return 1;
-    }
-    const result = (0, schemaUtils_1.validateAgainstDef)(resolved.defName, value);
-    if (result.valid) {
-        output_1.default.green(label);
-        return 0;
-    }
-    output_1.default.error(label);
-    outputErrors(result, '  ');
-    return result.errors.length;
-}
-function validateSinglePipeline(parsed, label) {
-    let errors = 0;
-    const defs = (0, schemaUtils_1.getAllDefs)();
-    const pipelineDef = defs['PipelineYaml'];
-    const props = pipelineDef?.properties || {};
-    const allKnownKeys = new Set([...Object.keys(props), ...SCHEMA_OMITTED_TOP_LEVEL_KEYS]);
-    const unknownKeys = Object.keys(parsed).filter((k) => !allKnownKeys.has(k));
-    if (unknownKeys.length > 0) {
-        output_1.default.yellow(`${label}Unknown top-level keys: ${unknownKeys.join(', ')}`);
-    }
-    const { itemSections, objectSections, settingsProps } = classifySections(props);
-    if (Object.keys(settingsProps).length > 0) {
-        const settingsData = {};
-        for (const key of Object.keys(settingsProps)) {
-            if (key in parsed)
-                settingsData[key] = parsed[key];
-        }
-        const rawSchema = (0, schemaUtils_1.loadRawSchema)();
-        const result = (0, schemaUtils_1.validateAgainstSchema)({
-            type: 'object',
-            properties: settingsProps,
-            required: (pipelineDef?.required || []).filter((r) => r in settingsProps),
-            $defs: rawSchema.$defs,
-        }, settingsData);
-        if (result.valid) {
-            output_1.default.green(`${label}Pipeline settings`);
-        }
-        else {
-            errors += result.errors.length;
-            output_1.default.error(`${label}Pipeline settings`);
-            outputErrors(result, '  ');
-        }
-    }
-    const itemByKey = new Map(itemSections.map((s) => [s.key, s.defName]));
-    const objByKey = new Map(objectSections.map((s) => [s.key, s.defName]));
-    for (const key of Object.keys(props)) {
-        if (!(key in parsed))
-            continue;
-        const value = parsed[key];
-        const header = `${label}${prettifyKey(key)}`;
-        if (itemByKey.has(key)) {
-            if (!Array.isArray(value))
-                continue;
-            output_1.default.blue(header);
-            errors += validateItemSection(defs, value, itemByKey.get(key));
-        }
-        else if (objByKey.has(key)) {
-            if (value === null || typeof value !== 'object' || Array.isArray(value))
-                continue;
-            errors += validateObjectSection(defs, header, value, objByKey.get(key));
-        }
-    }
-    return errors;
-}
-function validatePipelineFile(file) {
-    const filePath = (0, path_1.resolve)(file);
-    if (!(0, fs_1.existsSync)(filePath)) {
-        output_1.default.exitError((0, texts_1.ERR_YAML_VALIDATE_FILE_NOT_FOUND)(file));
-        return;
-    }
-    const YAML = require('yaml');
-    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
-    let parsed;
-    try {
-        parsed = YAML.parse(content);
-    }
-    catch (e) {
-        output_1.default.exitError(`YAML parse error: ${e.message}`);
-        return;
-    }
-    if (!parsed || typeof parsed !== 'object') {
-        output_1.default.exitError('Invalid pipeline YAML: expected an array of pipeline objects');
-        return;
-    }
-    if (!Array.isArray(parsed)) {
-        output_1.default.exitError('Invalid pipeline YAML: expected an array (e.g. "- pipeline: my-pipeline"), got a plain object');
-        return;
-    }
-    if (parsed.length === 0) {
-        output_1.default.exitError('Invalid pipeline YAML: empty array');
-        return;
-    }
-    let errors = 0;
-    for (let i = 0; i < parsed.length; i++) {
-        const pipeline = parsed[i];
-        if (!pipeline || typeof pipeline !== 'object' || Array.isArray(pipeline)) {
-            output_1.default.error(`  Pipeline #${i + 1}: expected an object`);
-            errors++;
-            continue;
-        }
-        const pipelineLabel = parsed.length > 1 ? `[${pipeline.pipeline || i + 1}] ` : '';
-        errors += validateSinglePipeline(pipeline, pipelineLabel);
-    }
-    output_1.default.normal('');
-    if (errors > 0) {
-        output_1.default.exitError(`${texts_1.ERR_YAML_VALIDATE_FAILED} (${errors} ${errors === 1 ? 'error' : 'errors'})`);
-    }
-    else {
-        output_1.default.exitSuccess(texts_1.TXT_YAML_VALIDATE_ALL_PASS);
-    }
-}
-const commandYamlValidate = (0, utils_1.newCommand)('validate', texts_1.DESC_COMMAND_YAML_VALIDATE);
-commandYamlValidate.argument('<file>', texts_1.OPTION_YAML_VALIDATE_FILE);
-commandYamlValidate.action(async (file) => {
-    await (0, schemaUtils_1.ensureYamlSchema)();
-    validatePipelineFile(file);
-});
-exports.default = commandYamlValidate;

package/distTs/src/command/yaml.js

@@ -1,18 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
-const texts_1 = require("../texts");
-const pipeline_1 = __importDefault(require("./yaml/pipeline"));
-const actions_1 = __importDefault(require("./yaml/actions"));
-const validate_1 = __importDefault(require("./yaml/validate"));
-const init_1 = __importDefault(require("./yaml/init"));
-const commandYaml = (0, utils_1.newCommand)('yaml', texts_1.DESC_COMMAND_YAML);
-commandYaml.addCommand(pipeline_1.default);
-commandYaml.addCommand(actions_1.default);
-commandYaml.addCommand(validate_1.default);
-commandYaml.addCommand(init_1.default);
-commandYaml.addHelpText('after', texts_1.EXAMPLE_YAML);
-exports.default = commandYaml;

package/distTs/src/diskCache.js

@@ -1,82 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CACHE_TTL_MS = void 0;
-exports.cacheRoot = cacheRoot;
-exports.hashKey = hashKey;
-exports.cachePaths = cachePaths;
-exports.readMeta = readMeta;
-exports.isHardFresh = isHardFresh;
-exports.writeAtomic = writeAtomic;
-exports.refresh = refresh;
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const undici_1 = require("undici");
-const utils_1 = require("./utils");
-exports.CACHE_TTL_MS = 60 * 60 * 1000; // 1h
-function cacheRoot() {
-    const dir = node_path_1.default.join((0, utils_1.getHomeDirectory)(), 'cache');
-    if (!(0, node_fs_1.existsSync)(dir))
-        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-    return dir;
-}
-function hashKey(input) {
-    return (0, node_crypto_1.createHash)('sha256').update(input).digest('hex').slice(0, 16);
-}
-function cachePaths(subdir, url) {
-    const dir = node_path_1.default.join(cacheRoot(), subdir);
-    if (!(0, node_fs_1.existsSync)(dir))
-        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-    const key = hashKey(url);
-    return {
-        raw: node_path_1.default.join(dir, `${key}.json`),
-        schema: node_path_1.default.join(dir, `${key}.v8`),
-        meta: node_path_1.default.join(dir, `${key}.meta.json`),
-    };
-}
-function readMeta(metaPath) {
-    try {
-        return JSON.parse((0, node_fs_1.readFileSync)(metaPath, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-}
-function isHardFresh(meta, ttlMs = exports.CACHE_TTL_MS) {
-    return !!meta.fetchedAt && Date.now() - meta.fetchedAt < ttlMs;
-}
-function writeAtomic(filePath, data) {
-    const tmp = `${filePath}.${process.pid}.tmp`;
-    (0, node_fs_1.writeFileSync)(tmp, data);
-    (0, node_fs_1.renameSync)(tmp, filePath);
-}
-async function refresh(url, paths) {
-    const hasRaw = (0, node_fs_1.existsSync)(paths.raw);
-    const meta = hasRaw ? readMeta(paths.meta) : {};
-    // The server serves a strong content-based ETag, so revalidate with If-None-Match.
-    const headers = {};
-    if (hasRaw && meta.etag)
-        headers['if-none-match'] = meta.etag;
-    try {
-        const res = await (0, undici_1.request)(url, { headers });
-        const etag = res.headers['etag'];
-        if (res.statusCode === 304 && hasRaw) {
-            await res.body.dump();
-            writeAtomic(paths.meta, JSON.stringify({ etag: meta.etag, fetchedAt: Date.now() }));
-            return 'unchanged';
-        }
-        if (res.statusCode >= 200 && res.statusCode < 300) {
-            writeAtomic(paths.raw, await res.body.text());
-            writeAtomic(paths.meta, JSON.stringify({ etag: typeof etag === 'string' ? etag : undefined, fetchedAt: Date.now() }));
-            return 'updated';
-        }
-        await res.body.dump();
-    }
-    catch {
-        // network error — fall back to the cached body if present
-    }
-    return hasRaw ? 'unchanged' : 'none';
-}