@pgpmjs/core 7.31.0 → 7.32.0

package/core/ci-matrix.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Insert `entry` into every test matrix of a workflow, keeping the list sorted.
+ * Only the byte range of each matrix sequence is rewritten; the rest of the
+ * source passes through untouched, so comments and formatting survive.
+ */
+export declare const addToMatrixYaml: (source: string, entry: string) => string;
+/**
+ * Add a module to the test matrix of a workspace's CI workflows, keeping the
+ * list sorted. The matrix stays a plain, hand-editable array: workflows without
+ * a `jobs.<job>.strategy.matrix.package` sequence are left alone.
+ * Best-effort: unreadable or unwritable workflows are skipped, never thrown.
+ *
+ * Returns the workflow files that changed, relative to `workspacePath`.
+ */
+export declare const addToCiMatrix: (workspacePath: string, modulePackagePath: string) => string[];

package/core/ci-matrix.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToCiMatrix = exports.addToMatrixYaml = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = require("yaml");
+const WORKFLOW_DIR = path_1.default.join('.github', 'workflows');
+const MATRIX_KEY = 'package';
+/** Column the node starts at, i.e. the indent of its first line. */
+const columnOf = (source, offset) => offset - (source.lastIndexOf('\n', offset - 1) + 1);
+/** Every `jobs.<job>.strategy.matrix.package` sequence in a workflow. */
+const findMatrixSeqs = (doc) => {
+    const jobs = doc.get('jobs', true);
+    if (!(0, yaml_1.isMap)(jobs))
+        return [];
+    const seqs = [];
+    for (const job of jobs.items) {
+        if (!(0, yaml_1.isScalar)(job.key))
+            continue;
+        const seq = doc.getIn(['jobs', job.key.value, 'strategy', 'matrix', MATRIX_KEY], true);
+        if ((0, yaml_1.isSeq)(seq))
+            seqs.push(seq);
+    }
+    return seqs;
+};
+/**
+ * The sequence's entries with their original source text (so quoting survives),
+ * or `null` if any item isn't a plain string scalar.
+ */
+const entriesOf = (seq, source) => {
+    const entries = [];
+    for (const item of seq.items) {
+        if (!(0, yaml_1.isScalar)(item) || typeof item.value !== 'string') {
+            return null;
+        }
+        const range = item.range;
+        if (!range)
+            return null;
+        const [start, end] = range;
+        entries.push({
+            value: item.value,
+            text: source.slice(start, end).trim(),
+            comment: item.comment,
+            commentBefore: item.commentBefore
+        });
+    }
+    return entries;
+};
+const commentLines = (comment) => comment ? comment.split('\n').filter((line) => line !== '') : [];
+/** Find standalone comment lines immediately before a node. */
+const commentBlockStart = (source, offset) => {
+    let lineStart = source.lastIndexOf('\n', offset - 1) + 1;
+    let first;
+    while (lineStart > 0) {
+        const lineEnd = lineStart - (source[lineStart - 1] === '\n' ? 1 : 0);
+        const previousStart = source.lastIndexOf('\n', lineEnd - 1) + 1;
+        const line = source.slice(previousStart, lineEnd).replace(/\r$/, '');
+        if (!/^\s*#/.test(line))
+            break;
+        first = previousStart;
+        lineStart = previousStart;
+    }
+    return first;
+};
+const renderCommentBefore = (comment, indent) => commentLines(comment)
+    .map((line) => `${indent}#${line}`)
+    .join('\n');
+const commentsOf = (doc) => {
+    const comments = [];
+    const add = (comment, multiline = false) => {
+        if (comment === null || comment === undefined)
+            return;
+        const values = multiline ? comment.split('\n') : [comment];
+        comments.push(...values.map((value) => value.trim()));
+    };
+    add(doc.comment);
+    add(doc.commentBefore, true);
+    if (doc.contents) {
+        (0, yaml_1.visit)(doc.contents, (_key, node) => {
+            if (!node || typeof node !== 'object')
+                return;
+            const commented = node;
+            add(commented.comment);
+            add(commented.commentBefore, true);
+        });
+    }
+    return comments.sort();
+};
+/** Re-render a sequence in the style and at the indent it was written with. */
+const renderSeq = (seq, entries, source, leadingComment = false) => {
+    const texts = entries.map((entry) => entry.text);
+    if (seq.flow) {
+        const original = seq.range
+            ? source.slice(seq.range[0], seq.range[1])
+            : '';
+        if (!original.includes('\n'))
+            return `[${texts.join(', ')}]`;
+        const firstItem = seq.items[0];
+        if (!(0, yaml_1.isScalar)(firstItem) || !firstItem.range) {
+            return `[${texts.join(', ')}]`;
+        }
+        const itemIndent = ' '.repeat(columnOf(source, firstItem.range[0]));
+        const closing = original.lastIndexOf(']');
+        const closingIndent = ' '.repeat(closing >= 0 ? columnOf(source, seq.range[0] + closing) : columnOf(source, seq.range[0]));
+        return `[\n${texts
+            .map((text, index) => `${itemIndent}${text}${index === texts.length - 1 ? '' : ','}`)
+            .join('\n')}\n${closingIndent}]`;
+    }
+    const indent = ' '.repeat(columnOf(source, seq.range[0]));
+    const rendered = entries.map((entry, index) => {
+        const before = renderCommentBefore(entry.commentBefore, indent);
+        const itemIndent = index === 0 && !entry.commentBefore && !leadingComment ? '' : indent;
+        const item = `${itemIndent}- ${entry.text}${entry.comment ? `  #${entry.comment}` : ''}`;
+        return before ? `${before}\n${item}` : item;
+    });
+    return rendered.join('\n');
+};
+/**
+ * Insert `entry` into every test matrix of a workflow, keeping the list sorted.
+ * Only the byte range of each matrix sequence is rewritten; the rest of the
+ * source passes through untouched, so comments and formatting survive.
+ */
+const addToMatrixYaml = (source, entry) => {
+    const doc = (0, yaml_1.parseDocument)(source);
+    if (doc.errors.length)
+        return source;
+    const added = {
+        value: entry,
+        text: (0, yaml_1.stringify)(entry).trim()
+    };
+    const edits = [];
+    for (const seq of findMatrixSeqs(doc)) {
+        const entries = entriesOf(seq, source);
+        if (!entries)
+            continue;
+        if (entries.some((existing) => existing.value === entry))
+            continue;
+        if (!seq.range)
+            continue;
+        if (seq.flow &&
+            (entries.some((existing) => existing.comment || existing.commentBefore) ||
+                seq.comment ||
+                seq.commentBefore)) {
+            continue;
+        }
+        const [originalStart, end] = seq.range;
+        const firstCommentStart = !seq.flow && (seq.commentBefore || entries[0]?.commentBefore)
+            ? commentBlockStart(source, originalStart)
+            : undefined;
+        const entriesWithComments = firstCommentStart === undefined || !seq.commentBefore || !entries[0]
+            ? entries
+            : [
+                {
+                    ...entries[0],
+                    commentBefore: entries[0].commentBefore
+                        ? `${seq.commentBefore}\n${entries[0].commentBefore}`
+                        : seq.commentBefore
+                },
+                ...entries.slice(1)
+            ];
+        const next = [...entriesWithComments, added]
+            .filter((item, index, all) => all.findIndex((other) => other.value === item.value) === index)
+            .sort((left, right) => left.value.localeCompare(right.value));
+        const start = firstCommentStart ?? originalStart;
+        // a block sequence's range extends to the next token; keep that whitespace
+        const [trailing] = /\s*$/.exec(source.slice(originalStart, end));
+        const rendered = renderSeq(seq, next, source, firstCommentStart !== undefined);
+        const replacement = rendered + trailing;
+        const candidate = source.slice(0, start) + replacement + source.slice(end);
+        const candidateDoc = (0, yaml_1.parseDocument)(candidate);
+        if (candidateDoc.errors.length ||
+            commentsOf(candidateDoc).join('\0') !== commentsOf(doc).join('\0')) {
+            continue;
+        }
+        edits.push({
+            start,
+            end,
+            text: replacement
+        });
+    }
+    // Last edit first, so earlier ranges keep their offsets.
+    return edits
+        .sort((left, right) => right.start - left.start)
+        .reduce((text, edit) => text.slice(0, edit.start) + edit.text + text.slice(edit.end), source);
+};
+exports.addToMatrixYaml = addToMatrixYaml;
+/**
+ * Add a module to the test matrix of a workspace's CI workflows, keeping the
+ * list sorted. The matrix stays a plain, hand-editable array: workflows without
+ * a `jobs.<job>.strategy.matrix.package` sequence are left alone.
+ * Best-effort: unreadable or unwritable workflows are skipped, never thrown.
+ *
+ * Returns the workflow files that changed, relative to `workspacePath`.
+ */
+const addToCiMatrix = (workspacePath, modulePackagePath) => {
+    const dir = path_1.default.join(workspacePath, WORKFLOW_DIR);
+    const entry = modulePackagePath.split(path_1.default.sep).join('/');
+    const changed = [];
+    try {
+        if (!fs_1.default.existsSync(dir))
+            return changed;
+        for (const file of fs_1.default.readdirSync(dir).sort()) {
+            if (!/\.ya?ml$/.test(file))
+                continue;
+            try {
+                const filePath = path_1.default.join(dir, file);
+                const original = fs_1.default.readFileSync(filePath, 'utf8');
+                const updated = (0, exports.addToMatrixYaml)(original, entry);
+                if (updated === original)
+                    continue;
+                fs_1.default.writeFileSync(filePath, updated);
+                changed.push(path_1.default.join(WORKFLOW_DIR, file).split(path_1.default.sep).join('/'));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return changed;
+    }
+    return changed;
+};
+exports.addToCiMatrix = addToCiMatrix;

package/esm/core/ci-matrix.js

@@ -0,0 +1,219 @@
+import fs from 'fs';
+import path from 'path';
+import { isMap, isScalar, isSeq, parseDocument, stringify, visit } from 'yaml';
+const WORKFLOW_DIR = path.join('.github', 'workflows');
+const MATRIX_KEY = 'package';
+/** Column the node starts at, i.e. the indent of its first line. */
+const columnOf = (source, offset) => offset - (source.lastIndexOf('\n', offset - 1) + 1);
+/** Every `jobs.<job>.strategy.matrix.package` sequence in a workflow. */
+const findMatrixSeqs = (doc) => {
+    const jobs = doc.get('jobs', true);
+    if (!isMap(jobs))
+        return [];
+    const seqs = [];
+    for (const job of jobs.items) {
+        if (!isScalar(job.key))
+            continue;
+        const seq = doc.getIn(['jobs', job.key.value, 'strategy', 'matrix', MATRIX_KEY], true);
+        if (isSeq(seq))
+            seqs.push(seq);
+    }
+    return seqs;
+};
+/**
+ * The sequence's entries with their original source text (so quoting survives),
+ * or `null` if any item isn't a plain string scalar.
+ */
+const entriesOf = (seq, source) => {
+    const entries = [];
+    for (const item of seq.items) {
+        if (!isScalar(item) || typeof item.value !== 'string') {
+            return null;
+        }
+        const range = item.range;
+        if (!range)
+            return null;
+        const [start, end] = range;
+        entries.push({
+            value: item.value,
+            text: source.slice(start, end).trim(),
+            comment: item.comment,
+            commentBefore: item.commentBefore
+        });
+    }
+    return entries;
+};
+const commentLines = (comment) => comment ? comment.split('\n').filter((line) => line !== '') : [];
+/** Find standalone comment lines immediately before a node. */
+const commentBlockStart = (source, offset) => {
+    let lineStart = source.lastIndexOf('\n', offset - 1) + 1;
+    let first;
+    while (lineStart > 0) {
+        const lineEnd = lineStart - (source[lineStart - 1] === '\n' ? 1 : 0);
+        const previousStart = source.lastIndexOf('\n', lineEnd - 1) + 1;
+        const line = source.slice(previousStart, lineEnd).replace(/\r$/, '');
+        if (!/^\s*#/.test(line))
+            break;
+        first = previousStart;
+        lineStart = previousStart;
+    }
+    return first;
+};
+const renderCommentBefore = (comment, indent) => commentLines(comment)
+    .map((line) => `${indent}#${line}`)
+    .join('\n');
+const commentsOf = (doc) => {
+    const comments = [];
+    const add = (comment, multiline = false) => {
+        if (comment === null || comment === undefined)
+            return;
+        const values = multiline ? comment.split('\n') : [comment];
+        comments.push(...values.map((value) => value.trim()));
+    };
+    add(doc.comment);
+    add(doc.commentBefore, true);
+    if (doc.contents) {
+        visit(doc.contents, (_key, node) => {
+            if (!node || typeof node !== 'object')
+                return;
+            const commented = node;
+            add(commented.comment);
+            add(commented.commentBefore, true);
+        });
+    }
+    return comments.sort();
+};
+/** Re-render a sequence in the style and at the indent it was written with. */
+const renderSeq = (seq, entries, source, leadingComment = false) => {
+    const texts = entries.map((entry) => entry.text);
+    if (seq.flow) {
+        const original = seq.range
+            ? source.slice(seq.range[0], seq.range[1])
+            : '';
+        if (!original.includes('\n'))
+            return `[${texts.join(', ')}]`;
+        const firstItem = seq.items[0];
+        if (!isScalar(firstItem) || !firstItem.range) {
+            return `[${texts.join(', ')}]`;
+        }
+        const itemIndent = ' '.repeat(columnOf(source, firstItem.range[0]));
+        const closing = original.lastIndexOf(']');
+        const closingIndent = ' '.repeat(closing >= 0 ? columnOf(source, seq.range[0] + closing) : columnOf(source, seq.range[0]));
+        return `[\n${texts
+            .map((text, index) => `${itemIndent}${text}${index === texts.length - 1 ? '' : ','}`)
+            .join('\n')}\n${closingIndent}]`;
+    }
+    const indent = ' '.repeat(columnOf(source, seq.range[0]));
+    const rendered = entries.map((entry, index) => {
+        const before = renderCommentBefore(entry.commentBefore, indent);
+        const itemIndent = index === 0 && !entry.commentBefore && !leadingComment ? '' : indent;
+        const item = `${itemIndent}- ${entry.text}${entry.comment ? `  #${entry.comment}` : ''}`;
+        return before ? `${before}\n${item}` : item;
+    });
+    return rendered.join('\n');
+};
+/**
+ * Insert `entry` into every test matrix of a workflow, keeping the list sorted.
+ * Only the byte range of each matrix sequence is rewritten; the rest of the
+ * source passes through untouched, so comments and formatting survive.
+ */
+export const addToMatrixYaml = (source, entry) => {
+    const doc = parseDocument(source);
+    if (doc.errors.length)
+        return source;
+    const added = {
+        value: entry,
+        text: stringify(entry).trim()
+    };
+    const edits = [];
+    for (const seq of findMatrixSeqs(doc)) {
+        const entries = entriesOf(seq, source);
+        if (!entries)
+            continue;
+        if (entries.some((existing) => existing.value === entry))
+            continue;
+        if (!seq.range)
+            continue;
+        if (seq.flow &&
+            (entries.some((existing) => existing.comment || existing.commentBefore) ||
+                seq.comment ||
+                seq.commentBefore)) {
+            continue;
+        }
+        const [originalStart, end] = seq.range;
+        const firstCommentStart = !seq.flow && (seq.commentBefore || entries[0]?.commentBefore)
+            ? commentBlockStart(source, originalStart)
+            : undefined;
+        const entriesWithComments = firstCommentStart === undefined || !seq.commentBefore || !entries[0]
+            ? entries
+            : [
+                {
+                    ...entries[0],
+                    commentBefore: entries[0].commentBefore
+                        ? `${seq.commentBefore}\n${entries[0].commentBefore}`
+                        : seq.commentBefore
+                },
+                ...entries.slice(1)
+            ];
+        const next = [...entriesWithComments, added]
+            .filter((item, index, all) => all.findIndex((other) => other.value === item.value) === index)
+            .sort((left, right) => left.value.localeCompare(right.value));
+        const start = firstCommentStart ?? originalStart;
+        // a block sequence's range extends to the next token; keep that whitespace
+        const [trailing] = /\s*$/.exec(source.slice(originalStart, end));
+        const rendered = renderSeq(seq, next, source, firstCommentStart !== undefined);
+        const replacement = rendered + trailing;
+        const candidate = source.slice(0, start) + replacement + source.slice(end);
+        const candidateDoc = parseDocument(candidate);
+        if (candidateDoc.errors.length ||
+            commentsOf(candidateDoc).join('\0') !== commentsOf(doc).join('\0')) {
+            continue;
+        }
+        edits.push({
+            start,
+            end,
+            text: replacement
+        });
+    }
+    // Last edit first, so earlier ranges keep their offsets.
+    return edits
+        .sort((left, right) => right.start - left.start)
+        .reduce((text, edit) => text.slice(0, edit.start) + edit.text + text.slice(edit.end), source);
+};
+/**
+ * Add a module to the test matrix of a workspace's CI workflows, keeping the
+ * list sorted. The matrix stays a plain, hand-editable array: workflows without
+ * a `jobs.<job>.strategy.matrix.package` sequence are left alone.
+ * Best-effort: unreadable or unwritable workflows are skipped, never thrown.
+ *
+ * Returns the workflow files that changed, relative to `workspacePath`.
+ */
+export const addToCiMatrix = (workspacePath, modulePackagePath) => {
+    const dir = path.join(workspacePath, WORKFLOW_DIR);
+    const entry = modulePackagePath.split(path.sep).join('/');
+    const changed = [];
+    try {
+        if (!fs.existsSync(dir))
+            return changed;
+        for (const file of fs.readdirSync(dir).sort()) {
+            if (!/\.ya?ml$/.test(file))
+                continue;
+            try {
+                const filePath = path.join(dir, file);
+                const original = fs.readFileSync(filePath, 'utf8');
+                const updated = addToMatrixYaml(original, entry);
+                if (updated === original)
+                    continue;
+                fs.writeFileSync(filePath, updated);
+                changed.push(path.join(WORKFLOW_DIR, file).split(path.sep).join('/'));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return changed;
+    }
+    return changed;
+};

package/esm/index.js

@@ -1,5 +1,6 @@
 export * from './core/boilerplate-scanner';
 export * from './core/boilerplate-types';
+export * from './core/ci-matrix';
 export * from './core/class/pgpm';
 export * from './core/template-scaffold';
 export * from './diff';

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './core/boilerplate-scanner';
 export * from './core/boilerplate-types';
+export * from './core/ci-matrix';
 export * from './core/class/pgpm';
 export * from './core/template-scaffold';
 export * from './diff';

package/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAuthor = exports.withTransaction = exports.executeQuery = exports.hashString = exports.hashSqlFile = exports.hashFile = exports.PgpmMigrate = exports.cleanSql = exports.PgpmInit = void 0;
 __exportStar(require("./core/boilerplate-scanner"), exports);
 __exportStar(require("./core/boilerplate-types"), exports);
+__exportStar(require("./core/ci-matrix"), exports);
 __exportStar(require("./core/class/pgpm"), exports);
 __exportStar(require("./core/template-scaffold"), exports);
 __exportStar(require("./diff"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "7.31.0",
+  "version": "7.32.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -49,15 +49,15 @@
     "makage": "^0.8.0"
   },
   "dependencies": {
-    "@pgpmjs/ast": "^0.15.0",
-    "@pgpmjs/bundle": "^0.18.0",
-    "@pgpmjs/diff": "^0.8.0",
-    "@pgpmjs/env": "^2.45.0",
+    "@pgpmjs/ast": "^0.15.1",
+    "@pgpmjs/bundle": "^0.18.1",
+    "@pgpmjs/diff": "^0.8.1",
+    "@pgpmjs/env": "^2.45.1",
     "@pgpmjs/logger": "^2.26.0",
-    "@pgpmjs/server-utils": "^3.29.0",
-    "@pgpmjs/slice": "^0.19.0",
-    "@pgpmjs/transform": "^0.28.0",
-    "@pgpmjs/types": "^2.55.0",
+    "@pgpmjs/server-utils": "^3.29.1",
+    "@pgpmjs/slice": "^0.19.1",
+    "@pgpmjs/transform": "^0.28.1",
+    "@pgpmjs/types": "^2.55.1",
     "cross-spawn": "^7.0.6",
     "csv-to-pg": "^4.14.0",
     "genomic": "^5.6.6",
@@ -65,11 +65,12 @@
     "glob": "^13.0.6",
     "parse-package-name": "^1.0.0",
     "pg": "^8.21.0",
-    "pg-cache": "^3.29.0",
+    "pg-cache": "^3.29.1",
     "pg-env": "^1.32.0",
     "pgsql-deparser": "^18.3.7",
     "pgsql-parser": "^18.2.7",
+    "yaml": "^2.9.0",
     "yanse": "^0.2.2"
   },
-  "gitHead": "75b888926505b473eeef7a76fea1554e5a1cf4cc"
+  "gitHead": "0e26550efd7cd782ecaa106be30b3251efd97e6e"
 }