@foss.global/forgefixtures 0.2.0

package/dist_ts/classes.httpclient.js

@@ -0,0 +1,116 @@
+import * as plugins from './plugins.js';
+export class ForgeFixtureHttpError extends Error {
+    status;
+    method;
+    path;
+    constructor(methodArg, pathArg, statusArg, bodyExcerptArg) {
+        super(`${methodArg} ${pathArg} answered ${statusArg}: ${bodyExcerptArg}`);
+        this.name = 'ForgeFixtureHttpError';
+        this.status = statusArg;
+        this.method = methodArg;
+        this.path = pathArg;
+    }
+}
+/**
+ * HTTPS client scoped to one fixture: it trusts only the fixture CA, talks only
+ * to the fixture origin, never follows redirects, and bounds time and body size.
+ * It changes no process-global TLS state.
+ */
+export class ForgeFixtureHttpClient {
+    #baseUrl;
+    #agent;
+    #requestTimeoutMs;
+    #maxResponseBytes;
+    constructor(optionsArg) {
+        const baseUrl = new URL(optionsArg.baseUrl);
+        if (baseUrl.protocol !== 'https:' || baseUrl.username || baseUrl.password || baseUrl.search || baseUrl.hash) {
+            throw new TypeError('The fixture base URL must be a credential-free HTTPS URL.');
+        }
+        this.#baseUrl = new URL(baseUrl.href.endsWith('/') ? baseUrl.href : `${baseUrl.href}/`);
+        this.#agent = new plugins.https.Agent({ ca: [optionsArg.caCertificatePem], keepAlive: true, maxSockets: 8 });
+        this.#requestTimeoutMs = optionsArg.requestTimeoutMs ?? 60_000;
+        this.#maxResponseBytes = optionsArg.maxResponseBytes ?? 16 * 1024 * 1024;
+    }
+    get baseUrl() {
+        return this.#baseUrl.href.replace(/\/$/, '');
+    }
+    /** Resolves a request target and refuses anything outside the fixture origin. */
+    resolve(urlArg, queryArg) {
+        const url = /^https?:\/\//.test(urlArg)
+            ? new URL(urlArg)
+            : new URL(urlArg.replace(/^\//, ''), this.#baseUrl);
+        if (url.origin !== this.#baseUrl.origin || url.username || url.password) {
+            throw new Error(`Refusing a request outside the fixture origin: ${url.origin}`);
+        }
+        for (const [key, value] of Object.entries(queryArg ?? {}))
+            url.searchParams.set(key, value);
+        return url;
+    }
+    async request(requestArg) {
+        if (requestArg.json !== undefined && requestArg.body !== undefined) {
+            throw new TypeError('A fixture request cannot carry both json and body.');
+        }
+        const url = this.resolve(requestArg.url, requestArg.query);
+        const payload = requestArg.json !== undefined
+            ? Buffer.from(JSON.stringify(requestArg.json))
+            : requestArg.body === undefined ? undefined : Buffer.from(requestArg.body);
+        const headers = { accept: 'application/json' };
+        for (const [name, value] of Object.entries(requestArg.headers ?? {}))
+            headers[name.toLowerCase()] = value;
+        if (requestArg.json !== undefined)
+            headers['content-type'] = 'application/json';
+        // A caller-requested transfer coding (for example Git LFS upload actions) replaces Content-Length.
+        if (payload !== undefined && headers['transfer-encoding'] === undefined) {
+            headers['content-length'] = String(payload.byteLength);
+        }
+        const timeoutMs = requestArg.timeoutMs ?? this.#requestTimeoutMs;
+        const maxResponseBytes = requestArg.maxResponseBytes ?? this.#maxResponseBytes;
+        const response = await new Promise((resolveArg, rejectArg) => {
+            const request = plugins.https.request(url, {
+                method: requestArg.method,
+                headers,
+                agent: this.#agent,
+                signal: AbortSignal.timeout(timeoutMs),
+            }, (responseArg) => {
+                const chunks = [];
+                let size = 0;
+                responseArg.on('data', (chunkArg) => {
+                    size += chunkArg.byteLength;
+                    if (size > maxResponseBytes) {
+                        responseArg.destroy(new Error(`${requestArg.method} ${url.pathname} exceeded ${maxResponseBytes} response bytes.`));
+                        return;
+                    }
+                    chunks.push(chunkArg);
+                });
+                responseArg.once('error', rejectArg);
+                responseArg.once('end', () => resolveArg({
+                    status: responseArg.statusCode ?? 0,
+                    headers: responseArg.headers,
+                    body: Buffer.concat(chunks),
+                }));
+            });
+            request.once('error', rejectArg);
+            request.end(payload);
+        });
+        if (!requestArg.expectedStatus.includes(response.status)) {
+            throw new ForgeFixtureHttpError(requestArg.method, url.pathname, response.status, response.body.subarray(0, 512).toString('utf8'));
+        }
+        return response;
+    }
+    /** Performs a request and parses its JSON body. An empty body yields `null`. */
+    async requestJson(requestArg) {
+        const response = await this.request(requestArg);
+        if (response.body.byteLength === 0)
+            return null;
+        const contentType = response.headers['content-type']?.split(';')[0]?.trim().toLowerCase();
+        if (contentType !== 'application/json' && contentType !== 'application/vnd.git-lfs+json') {
+            throw new Error(`${requestArg.method} ${requestArg.url} answered ${contentType ?? 'no content type'} instead of JSON.`);
+        }
+        return JSON.parse(response.body.toString('utf8'));
+    }
+    /** Destroys pooled connections. The client is unusable afterwards. */
+    close() {
+        this.#agent.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.reaper.d.ts

@@ -0,0 +1,25 @@
+import * as plugins from './plugins.js';
+import type { IForgeFixtureReapReport } from './interfaces.js';
+export interface IForgeFixtureReaperOptions {
+    /** Docker Engine socket; omit for `@apiclient.xyz/docker` resolution. */
+    dockerSocketPath?: string;
+}
+export interface IForgeFixtureInventory {
+    containers: plugins.docker.DockerContainer[];
+    networks: plugins.docker.DockerNetwork[];
+    volumes: plugins.docker.DockerVolume[];
+}
+export declare const createForgeFixtureDockerHost: (socketPathArg?: string) => plugins.docker.DockerHost;
+/** Lists every Docker resource carrying this package's managed label on one daemon. */
+export declare const listForgeFixtureResources: (dockerHostArg: plugins.docker.DockerHost) => Promise<IForgeFixtureInventory>;
+/**
+ * Removes the Docker resources of lifecycles whose owner process exited,
+ * whose host rebooted, or whose declared lifetime expired. Resources of live
+ * owners and resources with uninterpretable labels are left untouched.
+ */
+export declare class ForgeFixtureReaper {
+    #private;
+    constructor(optionsArg?: IForgeFixtureReaperOptions);
+    reap(nowArg?: Date): Promise<IForgeFixtureReapReport>;
+}
+export declare const reapStaleForgeFixtures: (dockerHostArg: plugins.docker.DockerHost, nowArg?: Date) => Promise<IForgeFixtureReapReport>;

package/dist_ts/classes.reaper.js

@@ -0,0 +1,102 @@
+import * as plugins from './plugins.js';
+import { forgeFixtureLabels } from './constants.js';
+import { classifyForgeFixtureOwner, parseForgeFixtureOwnerLabels, readCurrentProcessIdentity, } from './ownership.js';
+export const createForgeFixtureDockerHost = (socketPathArg) => new plugins.docker.DockerHost({
+    ...(socketPathArg === undefined ? {} : { socketPath: socketPathArg }),
+    enableImageStore: false,
+});
+const managedFilter = () => ({ label: [`${forgeFixtureLabels.managed}=true`] });
+/** Lists every Docker resource carrying this package's managed label on one daemon. */
+export const listForgeFixtureResources = async (dockerHostArg) => {
+    const [containers, networks, volumes] = await Promise.all([
+        dockerHostArg.listContainers({ all: true, filters: managedFilter() }),
+        dockerHostArg.listNetworks({ filters: managedFilter() }),
+        dockerHostArg.listVolumes({ filters: managedFilter() }),
+    ]);
+    return { containers, networks, volumes };
+};
+/**
+ * Removes the Docker resources of lifecycles whose owner process exited,
+ * whose host rebooted, or whose declared lifetime expired. Resources of live
+ * owners and resources with uninterpretable labels are left untouched.
+ */
+export class ForgeFixtureReaper {
+    #options;
+    constructor(optionsArg = {}) {
+        this.#options = { ...optionsArg };
+    }
+    async reap(nowArg = new Date()) {
+        const dockerHost = createForgeFixtureDockerHost(this.#options.dockerSocketPath);
+        try {
+            return await reapStaleForgeFixtures(dockerHost, nowArg);
+        }
+        finally {
+            await dockerHost.stop();
+        }
+    }
+}
+export const reapStaleForgeFixtures = async (dockerHostArg, nowArg = new Date()) => {
+    const current = await readCurrentProcessIdentity();
+    const inventory = await listForgeFixtureResources(dockerHostArg);
+    const report = {
+        removedContainers: [], removedNetworks: [], removedVolumes: [], reapedLifecycles: [], unrecognizedResources: [],
+    };
+    const verdicts = new Map();
+    const verdictFor = async (ownerArg) => {
+        let verdict = verdicts.get(ownerArg.lifecycleId);
+        if (verdict === undefined) {
+            verdict = await classifyForgeFixtureOwner(ownerArg, current, nowArg);
+            verdicts.set(ownerArg.lifecycleId, verdict);
+            if (verdict !== 'alive')
+                report.reapedLifecycles.push({ lifecycleId: ownerArg.lifecycleId, reason: verdict });
+        }
+        return verdict;
+    };
+    const stale = async (typeArg, idArg, labelsArg) => {
+        const owner = parseForgeFixtureOwnerLabels(labelsArg);
+        if (!owner) {
+            report.unrecognizedResources.push({ type: typeArg, id: idArg });
+            return false;
+        }
+        return (await verdictFor(owner)) !== 'alive';
+    };
+    const failures = [];
+    // Dependency order: containers release their network endpoints and volumes first.
+    for (const container of inventory.containers) {
+        if (!await stale('container', container.Id, container.Labels))
+            continue;
+        try {
+            await container.remove({ force: true, removeAnonymousVolumes: true });
+            report.removedContainers.push(container.Id);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    for (const network of inventory.networks) {
+        if (!await stale('network', network.Id, network.Labels))
+            continue;
+        try {
+            await network.remove();
+            report.removedNetworks.push(network.Id);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    for (const volume of inventory.volumes) {
+        if (!await stale('volume', volume.Name, volume.Labels))
+            continue;
+        try {
+            await volume.remove({ force: true });
+            report.removedVolumes.push(volume.Name);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length > 0)
+        throw new AggregateError(failures, 'Forge fixture reaping left stale resources behind.');
+    return report;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.tlsterminator.d.ts

@@ -0,0 +1,21 @@
+import type { IForgeFixtureServerCertificate } from './classes.certificateauthority.js';
+/**
+ * Loopback TLS-terminating reverse proxy in front of one loopback HTTP
+ * upstream, configured the way a production proxy is: the client's Host header
+ * is preserved and `X-Forwarded-Proto: https` tells the forge the public scheme.
+ * It listens before the forge starts, so the forge can be configured with its
+ * exact external HTTPS origin.
+ */
+export declare class ForgeFixtureTlsTerminator {
+    #private;
+    constructor(certificateArg: IForgeFixtureServerCertificate);
+    /** Last error the listening server emitted, if any. */
+    get lastServerError(): Error | undefined;
+    /** Bound loopback port, available after `listen()`. */
+    get port(): number;
+    listen(): Promise<number>;
+    /** Requests received before an upstream is set are answered with 503. */
+    setUpstreamPort(portArg: number): void;
+    /** Stops listening and destroys every open client and upstream connection. Idempotent. */
+    close(): Promise<void>;
+}

package/dist_ts/classes.tlsterminator.js

@@ -0,0 +1,131 @@
+import * as plugins from './plugins.js';
+/** RFC 9110 hop-by-hop fields; they describe one connection and are never forwarded. */
+const hopByHopHeaders = new Set([
+    'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'proxy-connection',
+    'te', 'trailer', 'transfer-encoding', 'upgrade',
+]);
+const forwardableHeaders = (headersArg) => {
+    const connectionTokens = new Set(String(headersArg.connection ?? '').split(',').map((tokenArg) => tokenArg.trim().toLowerCase()).filter(Boolean));
+    const headers = {};
+    for (const [name, value] of Object.entries(headersArg)) {
+        if (value === undefined || hopByHopHeaders.has(name) || connectionTokens.has(name))
+            continue;
+        headers[name] = value;
+    }
+    return headers;
+};
+/**
+ * Loopback TLS-terminating reverse proxy in front of one loopback HTTP
+ * upstream, configured the way a production proxy is: the client's Host header
+ * is preserved and `X-Forwarded-Proto: https` tells the forge the public scheme.
+ * It listens before the forge starts, so the forge can be configured with its
+ * exact external HTTPS origin.
+ */
+export class ForgeFixtureTlsTerminator {
+    #server;
+    #agent = new plugins.http.Agent({ keepAlive: true, maxSockets: 32 });
+    #upstreamPort;
+    #port;
+    #closed = false;
+    #lastServerError;
+    constructor(certificateArg) {
+        this.#server = plugins.https.createServer({
+            cert: certificateArg.certificatePem,
+            key: certificateArg.privateKeyPem,
+            minVersion: 'TLSv1.2',
+        }, (requestArg, responseArg) => this.#forward(requestArg, responseArg));
+        // Handshake failures concern only that client; the listener stays up.
+        this.#server.on('tlsClientError', (_errorArg, socketArg) => socketArg.destroy());
+        // A server error must never become an unhandled 'error' event that crashes
+        // the test process; it is recorded for diagnostics instead.
+        this.#server.on('error', (errorArg) => {
+            this.#lastServerError = errorArg;
+        });
+    }
+    /** Last error the listening server emitted, if any. */
+    get lastServerError() {
+        return this.#lastServerError;
+    }
+    /** Bound loopback port, available after `listen()`. */
+    get port() {
+        if (this.#port === undefined)
+            throw new Error('The TLS terminator is not listening.');
+        return this.#port;
+    }
+    async listen() {
+        if (this.#closed)
+            throw new Error('The TLS terminator is closed.');
+        if (this.#port !== undefined)
+            return this.#port;
+        await new Promise((resolveArg, rejectArg) => {
+            const onError = (errorArg) => rejectArg(errorArg);
+            this.#server.once('error', onError);
+            this.#server.listen({ host: '127.0.0.1', port: 0, exclusive: true }, () => {
+                this.#server.off('error', onError);
+                resolveArg();
+            });
+        });
+        const address = this.#server.address();
+        if (address === null || typeof address === 'string')
+            throw new Error('The TLS terminator has no TCP address.');
+        this.#port = address.port;
+        return address.port;
+    }
+    /** Requests received before an upstream is set are answered with 503. */
+    setUpstreamPort(portArg) {
+        if (!Number.isSafeInteger(portArg) || portArg < 1 || portArg > 65535) {
+            throw new TypeError('The upstream port must be an integer from 1 through 65535.');
+        }
+        this.#upstreamPort = portArg;
+    }
+    /** Stops listening and destroys every open client and upstream connection. Idempotent. */
+    async close() {
+        this.#closed = true;
+        this.#agent.destroy();
+        if (!this.#server.listening)
+            return;
+        const closed = new Promise((resolveArg, rejectArg) => {
+            this.#server.close((errorArg) => (errorArg ? rejectArg(errorArg) : resolveArg()));
+        });
+        this.#server.closeAllConnections();
+        await closed;
+    }
+    #forward(requestArg, responseArg) {
+        const upstreamPort = this.#upstreamPort;
+        if (this.#closed || upstreamPort === undefined) {
+            responseArg.writeHead(503, { 'content-type': 'text/plain', connection: 'close' });
+            responseArg.end('The forge fixture is not ready.\n');
+            return;
+        }
+        const headers = forwardableHeaders(requestArg.headers);
+        headers['x-forwarded-proto'] = 'https';
+        headers['x-forwarded-for'] = requestArg.socket.remoteAddress ?? '127.0.0.1';
+        const upstreamRequest = plugins.http.request({
+            host: '127.0.0.1',
+            port: upstreamPort,
+            method: requestArg.method,
+            path: requestArg.url,
+            headers,
+            agent: this.#agent,
+        }, (upstreamResponse) => {
+            responseArg.writeHead(upstreamResponse.statusCode ?? 502, forwardableHeaders(upstreamResponse.headers));
+            upstreamResponse.pipe(responseArg);
+            upstreamResponse.once('error', () => responseArg.destroy());
+        });
+        upstreamRequest.once('error', () => {
+            if (responseArg.headersSent) {
+                responseArg.destroy();
+                return;
+            }
+            responseArg.writeHead(502, { 'content-type': 'text/plain', connection: 'close' });
+            responseArg.end('The forge fixture upstream is unavailable.\n');
+        });
+        requestArg.once('error', () => upstreamRequest.destroy());
+        responseArg.once('close', () => {
+            if (!responseArg.writableFinished)
+                upstreamRequest.destroy();
+        });
+        requestArg.pipe(upstreamRequest);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/constants.d.ts

@@ -0,0 +1,22 @@
+import type { IForgeFixtureImage } from './interfaces.js';
+/** Gitea release that code.foss.global serves (`/api/v1/version`). Rootless variant, uid 1000. */
+export declare const giteaFixtureImage: IForgeFixtureImage;
+/** Self-managed GitLab Community Edition. The omnibus image runs as root, so it runs on a rootless daemon. */
+export declare const gitlabFixtureImage: IForgeFixtureImage;
+/** Prefix of every Docker label this package writes. */
+export declare const forgeFixtureLabelPrefix = "global.foss.forgefixtures";
+export declare const forgeFixtureLabels: Readonly<{
+    managed: "global.foss.forgefixtures.managed";
+    lifecycleId: "global.foss.forgefixtures.lifecycle";
+    kind: "global.foss.forgefixtures.kind";
+    machineId: "global.foss.forgefixtures.owner.machineid";
+    hostname: "global.foss.forgefixtures.owner.hostname";
+    bootId: "global.foss.forgefixtures.owner.bootid";
+    pidNamespace: "global.foss.forgefixtures.owner.pidns";
+    pid: "global.foss.forgefixtures.owner.pid";
+    processStartTicks: "global.foss.forgefixtures.owner.starttime";
+    createdAt: "global.foss.forgefixtures.createdat";
+    expiresAt: "global.foss.forgefixtures.expiresat";
+}>;
+export declare const defaultMaxLifetimeMs: number;
+export declare const defaultPullTimeoutMs: number;

package/dist_ts/constants.js

@@ -0,0 +1,30 @@
+/** Gitea release that code.foss.global serves (`/api/v1/version`). Rootless variant, uid 1000. */
+export const giteaFixtureImage = Object.freeze({
+    version: '1.27.3',
+    tag: 'gitea/gitea:1.27.3-rootless',
+    repoDigest: 'gitea/gitea@sha256:1c17ecaead42eb3b5391553d8708103a4beb0e86edf5b9ebc1eb269c318845f2',
+});
+/** Self-managed GitLab Community Edition. The omnibus image runs as root, so it runs on a rootless daemon. */
+export const gitlabFixtureImage = Object.freeze({
+    version: '19.4.1',
+    tag: 'gitlab/gitlab-ce:19.4.1-ce.0',
+    repoDigest: 'gitlab/gitlab-ce@sha256:9b33b45b9f42d176bada85ee5ecb81ddab7e506c435f44cd582206e284b2809c',
+});
+/** Prefix of every Docker label this package writes. */
+export const forgeFixtureLabelPrefix = 'global.foss.forgefixtures';
+export const forgeFixtureLabels = Object.freeze({
+    managed: `${forgeFixtureLabelPrefix}.managed`,
+    lifecycleId: `${forgeFixtureLabelPrefix}.lifecycle`,
+    kind: `${forgeFixtureLabelPrefix}.kind`,
+    machineId: `${forgeFixtureLabelPrefix}.owner.machineid`,
+    hostname: `${forgeFixtureLabelPrefix}.owner.hostname`,
+    bootId: `${forgeFixtureLabelPrefix}.owner.bootid`,
+    pidNamespace: `${forgeFixtureLabelPrefix}.owner.pidns`,
+    pid: `${forgeFixtureLabelPrefix}.owner.pid`,
+    processStartTicks: `${forgeFixtureLabelPrefix}.owner.starttime`,
+    createdAt: `${forgeFixtureLabelPrefix}.createdat`,
+    expiresAt: `${forgeFixtureLabelPrefix}.expiresat`,
+});
+export const defaultMaxLifetimeMs = 2 * 60 * 60 * 1000;
+export const defaultPullTimeoutMs = 15 * 60 * 1000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLGtHQUFrRztBQUNsRyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBdUIsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUNqRSxPQUFPLEVBQUUsUUFBUTtJQUNqQixHQUFHLEVBQUUsNkJBQTZCO0lBQ2xDLFVBQVUsRUFBRSxxRkFBcUY7Q0FDbEcsQ0FBQyxDQUFDO0FBRUgsOEdBQThHO0FBQzlHLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUF1QixNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ2xFLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLEdBQUcsRUFBRSw4QkFBOEI7SUFDbkMsVUFBVSxFQUFFLDBGQUEwRjtDQUN2RyxDQUFDLENBQUM7QUFFSCx3REFBd0Q7QUFDeEQsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsMkJBQTJCLENBQUM7QUFFbkUsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUM5QyxPQUFPLEVBQUUsR0FBRyx1QkFBdUIsVUFBVTtJQUM3QyxXQUFXLEVBQUUsR0FBRyx1QkFBdUIsWUFBWTtJQUNuRCxJQUFJLEVBQUUsR0FBRyx1QkFBdUIsT0FBTztJQUN2QyxTQUFTLEVBQUUsR0FBRyx1QkFBdUIsa0JBQWtCO0lBQ3ZELFFBQVEsRUFBRSxHQUFHLHVCQUF1QixpQkFBaUI7SUFDckQsTUFBTSxFQUFFLEdBQUcsdUJBQXVCLGVBQWU7SUFDakQsWUFBWSxFQUFFLEdBQUcsdUJBQXVCLGNBQWM7SUFDdEQsR0FBRyxFQUFFLEdBQUcsdUJBQXVCLFlBQVk7SUFDM0MsaUJBQWlCLEVBQUUsR0FBRyx1QkFBdUIsa0JBQWtCO0lBQy9ELFNBQVMsRUFBRSxHQUFHLHVCQUF1QixZQUFZO0lBQ2pELFNBQVMsRUFBRSxHQUFHLHVCQUF1QixZQUFZO0NBQ2xELENBQUMsQ0FBQztBQUVILE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQztBQUN2RCxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyJ9

package/dist_ts/giteaseed.default.d.ts

@@ -0,0 +1,10 @@
+import type { IGiteaSeedSpec } from './interfaces.giteaseed.js';
+/**
+ * A compact seed covering the Gitea behaviours inventory readers must handle:
+ * public, limited and private owners, private repositories, a public
+ * repository of a private organization (which Gitea reports as `internal`),
+ * issue and pull request numbers from one sequence, closed items, labels,
+ * milestones, assignees, comments, tags, releases, an LFS object and a
+ * deleted author whose content Gitea reattributes to its ghost user.
+ */
+export declare const createDefaultGiteaSeedSpec: () => IGiteaSeedSpec;

package/dist_ts/giteaseed.default.js

@@ -0,0 +1,87 @@
+/**
+ * A compact seed covering the Gitea behaviours inventory readers must handle:
+ * public, limited and private owners, private repositories, a public
+ * repository of a private organization (which Gitea reports as `internal`),
+ * issue and pull request numbers from one sequence, closed items, labels,
+ * milestones, assignees, comments, tags, releases, an LFS object and a
+ * deleted author whose content Gitea reattributes to its ghost user.
+ */
+export const createDefaultGiteaSeedSpec = () => ({
+    users: [
+        { username: 'alice', fullName: 'Alice Example' },
+        { username: 'bob', fullName: 'Bob Example' },
+        { username: 'carol', visibility: 'private' },
+        { username: 'dora' },
+    ],
+    organizations: [
+        { name: 'team-with-hyphens', visibility: 'public' },
+        { name: 'limited-org', visibility: 'limited' },
+        { name: 'private-org', visibility: 'private' },
+    ],
+    repositories: [
+        {
+            owner: 'team-with-hyphens',
+            name: 'public-repo',
+            private: false,
+            description: 'Public organization repository',
+            collaborators: [{ username: 'bob', permission: 'write' }],
+            files: [{ path: 'src/index.ts', content: 'export const seeded = true;\n' }],
+            branches: [{ name: 'feature-a', files: [{ path: 'src/feature.ts', content: 'export const feature = 1;\n' }] }],
+            labels: [
+                { name: 'bug', color: '#d73a4a' },
+                { name: 'enhancement', color: '#a2eeef' },
+            ],
+            milestones: [
+                { title: 'v1', state: 'open' },
+                { title: 'v0', state: 'closed' },
+            ],
+            tags: [{ name: 'v1.0.0', target: 'main', message: 'First release' }],
+            issuesAndPullRequests: [
+                {
+                    kind: 'issue', key: 'open-labelled', title: 'Open labelled issue', body: 'Body with #2 reference', author: 'alice',
+                    state: 'open', labels: ['bug'], milestone: 'v1', assignees: ['bob'],
+                    comments: [{ author: 'bob', body: 'Confirmed.' }],
+                },
+                { kind: 'pullRequest', key: 'feature-pr', title: 'Add feature', author: 'bob', head: 'feature-a', base: 'main', state: 'open', labels: ['enhancement'] },
+                {
+                    kind: 'issue', key: 'closed-by-deleted-user', title: 'Closed issue from a deleted user', author: 'dora', state: 'closed',
+                    milestone: 'v0', comments: [{ author: 'dora', body: 'Comment from a user who will be deleted.' }],
+                },
+            ],
+            releases: [{ tagName: 'v1.0.0', target: 'main', name: 'v1.0.0', body: 'Release notes' }],
+            lfsObjects: [{ path: 'assets/blob.bin', content: 'forgefixtures LFS payload\n' }],
+        },
+        {
+            owner: 'limited-org',
+            name: 'limited-repo',
+            private: false,
+            issuesAndPullRequests: [{ kind: 'issue', key: 'limited-issue', title: 'Issue in a limited organization', author: 'alice', state: 'open' }],
+        },
+        {
+            owner: 'private-org',
+            name: 'internal-repo',
+            private: false,
+            collaborators: [{ username: 'alice', permission: 'read' }],
+            issuesAndPullRequests: [{ kind: 'issue', key: 'internal-issue', title: 'Issue in a private organization', author: 'alice', state: 'open' }],
+        },
+        {
+            owner: 'private-org',
+            name: 'secret-repo',
+            private: true,
+            collaborators: [{ username: 'alice', permission: 'read' }],
+            issuesAndPullRequests: [{ kind: 'issue', key: 'private-issue', title: 'Issue in a private repository', author: 'alice', state: 'open' }],
+        },
+        {
+            owner: 'alice',
+            name: 'personal-repo',
+            private: false,
+            branches: [{ name: 'topic', files: [{ path: 'notes.md', content: '# Notes\n' }] }],
+            issuesAndPullRequests: [
+                { kind: 'pullRequest', key: 'closed-pr', title: 'Closed proposal', author: 'alice', head: 'topic', base: 'main', state: 'closed' },
+                { kind: 'issue', key: 'after-pr', title: 'Issue numbered after a pull request', author: 'carol', state: 'closed' },
+            ],
+        },
+    ],
+    deleteUsers: ['dora'],
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/gitlabseed.default.d.ts

@@ -0,0 +1,12 @@
+import type { IGitlabSeedSpec } from './interfaces.gitlabseed.js';
+/** Projects created in `bulk-group` so project listings span more than one default page (20). */
+export declare const defaultGitlabBulkProjectCount = 22;
+/**
+ * A compact seed covering the GitLab behaviours inventory readers must handle:
+ * nested groups with public, internal and private visibility, a personal
+ * project, confidential issues and incidents, separate issue and merge request
+ * IID sequences, closed items, labels, milestones, assignees, notes, tags,
+ * releases, a deleted author whose content GitLab moves to its ghost user, and
+ * more projects than one page of a project listing.
+ */
+export declare const createDefaultGitlabSeedSpec: () => IGitlabSeedSpec;