@foss.global/forgefixtures 0.2.0

package/dist_ts/classes.gitlabfixture.js

@@ -0,0 +1,237 @@
+import { gitlabFixtureImage } from './constants.js';
+import { ForgeFixtureContainerLifecycle } from './classes.containerlifecycle.js';
+const httpPort = 80;
+const adminUsername = 'root';
+const usernamePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,254}$/;
+const tokenNamePattern = /^[A-Za-z0-9 _.-]{1,64}$/;
+const scopePattern = /^[a-z_]{1,64}$/;
+const tokenMarker = 'FORGEFIXTURES_TOKEN=';
+const tokenPattern = /^[A-Za-z0-9_.-]{20,256}$/;
+const railsRunnerTimeoutMs = 10 * 60 * 1000;
+/**
+ * Written by the image's post-reconfigure hook (`GITLAB_POST_RECONFIGURE_SCRIPT`,
+ * evaluated by `/assets/init-container` once `gitlab-ctl reconfigure` returned).
+ * Before that, services are still being configured and restarted.
+ */
+const reconfiguredMarker = '/run/forgefixtures-reconfigured';
+const sleep = (msArg) => new Promise((resolveArg) => setTimeout(resolveArg, msArg));
+/** Default rootless Docker socket of the current user. */
+export const defaultRootlessDockerSocket = () => {
+    const runtimeDirectory = process.env.XDG_RUNTIME_DIR ?? `/run/user/${process.getuid?.() ?? 0}`;
+    return `unix://${runtimeDirectory}/docker.sock`;
+};
+/**
+ * Memory-constrained omnibus configuration from GitLab's documentation for
+ * small instances, behind this package's TLS-terminating proxy.
+ */
+const omnibusConfiguration = (baseUrlArg) => [
+    `external_url '${baseUrlArg}'`,
+    `nginx['listen_port'] = ${httpPort}`,
+    `nginx['listen_https'] = false`,
+    `letsencrypt['enable'] = false`,
+    `puma['worker_processes'] = 0`,
+    `sidekiq['concurrency'] = 10`,
+    `prometheus_monitoring['enable'] = false`,
+    `gitlab_kas['enable'] = false`,
+    `gitlab_rails['usage_ping_enabled'] = false`,
+    `gitlab_rails['env'] = { 'MALLOC_CONF' => 'dirty_decay_ms:1000,muzzy_decay_ms:1000' }`,
+    `gitaly['env'] = { 'MALLOC_CONF' => 'dirty_decay_ms:1000,muzzy_decay_ms:1000', 'GITALY_COMMAND_SPAWN_MAX_PARALLEL' => '2' }`,
+].join('\n');
+/**
+ * A disposable self-managed GitLab CE from the pinned omnibus image, served over
+ * verified loopback TLS. The omnibus image must run as root, which this package
+ * permits only on a verified rootless Docker daemon.
+ */
+export class GitlabFixture {
+    #options;
+    #lifecycle;
+    #runtime;
+    #starting;
+    constructor(optionsArg = {}) {
+        this.#options = { ...optionsArg };
+        this.#lifecycle = new ForgeFixtureContainerLifecycle('gitlab', {
+            ...optionsArg,
+            dockerSocketPath: optionsArg.dockerSocketPath ?? defaultRootlessDockerSocket(),
+        }, 12 * 60 * 1000);
+    }
+    get runtime() {
+        if (!this.#runtime)
+            throw new Error('The GitLab fixture is not running.');
+        return this.#runtime;
+    }
+    /** HTTPS client scoped to this fixture's origin and CA. */
+    get http() {
+        return this.#lifecycle.http;
+    }
+    /** Report of the stale-fixture reaper run that preceded this start. */
+    get reapReport() {
+        return this.#lifecycle.lastReapReport;
+    }
+    /**
+     * Starts the fixture and returns once the container is healthy, an
+     * administrator token exists and GitLab reports the pinned version.
+     * A fixture starts at most once.
+     */
+    start() {
+        if (this.#starting)
+            return Promise.reject(new Error('The GitLab fixture was already started.'));
+        this.#starting = this.#start();
+        return this.#starting;
+    }
+    async #start() {
+        const endpoint = await this.#lifecycle.prepare();
+        try {
+            await this.#lifecycle.startContainer({
+                image: gitlabFixtureImage,
+                user: 'root',
+                allowRootOnRootless: true,
+                command: ['/assets/init-container'],
+                env: {
+                    GITLAB_OMNIBUS_CONFIG: omnibusConfiguration(endpoint.baseUrl),
+                    GITLAB_POST_RECONFIGURE_SCRIPT: `touch ${reconfiguredMarker}`,
+                },
+                httpPort,
+                volumes: [
+                    { purpose: 'config', target: '/etc/gitlab' },
+                    { purpose: 'data', target: '/var/opt/gitlab' },
+                    { purpose: 'logs', target: '/var/log/gitlab' },
+                ],
+                memoryBytes: this.#options.memoryBytes ?? 5 * 1024 * 1024 * 1024,
+                nanoCpus: this.#options.nanoCpus ?? 4_000_000_000,
+                pidsLimit: 4096,
+                shmSizeBytes: 256 * 1024 * 1024,
+                stopTimeoutSeconds: 30,
+                // The image's own HTTP check, gated on the finished reconfigure: before reconfigure
+                // renders its target, `gitlab-healthcheck` succeeds without checking anything.
+                healthcheck: {
+                    test: ['CMD-SHELL', `test -e ${reconfiguredMarker} && exec /opt/gitlab/bin/gitlab-healthcheck --fail --max-time 10`],
+                    intervalMs: 10_000,
+                    timeoutMs: 30_000,
+                    startPeriodMs: this.#lifecycle.startupTimeoutMs,
+                    startIntervalMs: 5_000,
+                    retries: 5,
+                },
+            });
+            await this.#waitForReady(Date.now() + this.#lifecycle.startupTimeoutMs);
+            const token = await this.createAccessToken({
+                username: adminUsername, tokenName: 'forgefixtures-admin', scopes: ['api', 'sudo'],
+            });
+            this.#lifecycle.assertNotStopping();
+            const version = await this.#readVersion(token);
+            if (version !== gitlabFixtureImage.version) {
+                throw new Error(`GitLab reports version ${version}; the pinned image is ${gitlabFixtureImage.version}.`);
+            }
+            this.#lifecycle.assertNotStopping();
+            this.#runtime = {
+                kind: 'gitlab',
+                lifecycleId: this.#lifecycle.lifecycleId,
+                baseUrl: endpoint.baseUrl,
+                caCertificatePem: endpoint.caCertificatePem,
+                version,
+                image: gitlabFixtureImage,
+                admin: { username: adminUsername, token },
+            };
+            return this.#runtime;
+        }
+        catch (error) {
+            const reported = this.#lifecycle.stopAwareError(error);
+            try {
+                await this.#lifecycle.stop();
+            }
+            catch (cleanupError) {
+                throw new AggregateError([reported, cleanupError], 'The GitLab fixture failed to start and to clean up.');
+            }
+            throw reported;
+        }
+    }
+    /**
+     * Creates a personal access token with GitLab's documented programmatic
+     * method (`gitlab-rails runner`). The script travels on stdin, so neither it
+     * nor the token appears in process arguments; the token is returned, never logged.
+     */
+    async createAccessToken(requestArg) {
+        if (!usernamePattern.test(requestArg.username) || !tokenNamePattern.test(requestArg.tokenName)
+            || requestArg.scopes.length === 0 || !requestArg.scopes.every((scopeArg) => scopePattern.test(scopeArg))) {
+            throw new TypeError('The access token request is malformed.');
+        }
+        const script = [
+            `user = User.find_by_username!(${JSON.stringify(requestArg.username)})`,
+            `token = user.personal_access_tokens.create!(name: ${JSON.stringify(requestArg.tokenName)}, `
+                + `scopes: ${JSON.stringify(requestArg.scopes)}, expires_at: 2.days.from_now)`,
+            `puts "${tokenMarker}#{token.token}"`,
+        ].join('\n');
+        const result = await this.#lifecycle.exec(['/opt/gitlab/bin/gitlab-rails', 'runner', '-'], {
+            stdin: script, timeoutMs: railsRunnerTimeoutMs,
+        });
+        if (result.exitCode !== 0) {
+            // A failed run printed no token; its output carries Rails' error report.
+            const diagnostics = `${result.stderr}\n${result.stdout}`.split('\n')
+                .filter((lineArg) => !lineArg.startsWith(tokenMarker)).join('\n').trim().slice(-2048);
+            throw new Error(`gitlab-rails runner failed to create a token for ${requestArg.username} (exit ${result.exitCode}): ${diagnostics}`);
+        }
+        const line = result.stdout.split('\n').find((lineArg) => lineArg.startsWith(tokenMarker));
+        const token = line?.slice(tokenMarker.length).trim();
+        if (!token || !tokenPattern.test(token))
+            throw new Error('gitlab-rails runner returned no access token in the expected format.');
+        return token;
+    }
+    /**
+     * Removes every resource of this fixture. A start in progress is cancelled at
+     * its next checkpoint and awaited first, so nothing it created survives.
+     * Idempotent; retries incomplete cleanup.
+     */
+    async stop() {
+        this.#runtime = undefined;
+        this.#lifecycle.requestStop();
+        const starting = this.#starting;
+        if (starting)
+            await starting.catch(() => undefined);
+        await this.#lifecycle.stop();
+    }
+    /**
+     * Waits until Docker reports the container healthy, which requires the
+     * finished reconfigure and a passing image HTTP check, and until the Rails
+     * API answers behind the proxy: an unauthenticated `/api/v4/version`
+     * answering 401 proves that nginx, Workhorse and Puma serve the API. Docker
+     * counts failed checks only after the first success, so `unhealthy` means
+     * GitLab broke after it was up.
+     */
+    async #waitForReady(deadlineArg) {
+        let health = 'none';
+        let api = 'not probed';
+        while (Date.now() < deadlineArg) {
+            this.#lifecycle.assertNotStopping();
+            await this.#lifecycle.assertContainerRunning();
+            health = await this.#lifecycle.containerHealth();
+            if (health === 'unhealthy')
+                break;
+            if (health === 'healthy') {
+                try {
+                    const response = await this.#lifecycle.http.request({
+                        method: 'GET', url: '/api/v4/version', expectedStatus: [401, 502, 503], timeoutMs: 10_000,
+                    });
+                    if (response.status === 401)
+                        return;
+                    api = `status ${response.status}`;
+                }
+                catch (error) {
+                    api = error instanceof Error ? error.message : String(error);
+                }
+            }
+            await sleep(5_000);
+        }
+        this.#lifecycle.assertNotStopping();
+        const reason = health === 'unhealthy' ? 'became unhealthy' : `did not become ready within ${this.#lifecycle.startupTimeoutMs} ms`;
+        throw new Error(`GitLab ${reason} (health ${health}, API ${api}). Last logs:\n${await this.#lifecycle.logsTail(60)}`);
+    }
+    async #readVersion(tokenArg) {
+        const body = await this.#lifecycle.http.requestJson({
+            method: 'GET', url: '/api/v4/version', headers: { 'private-token': tokenArg }, expectedStatus: [200],
+        });
+        const version = typeof body === 'object' && body !== null ? Reflect.get(body, 'version') : undefined;
+        if (typeof version !== 'string')
+            throw new Error('GitLab answered /api/v4/version without a version.');
+        return version;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.gitlabfixture.js","sourceRoot":"","sources":["../ts/classes.gitlabfixture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AAmBjF,MAAM,QAAQ,GAAG,EAAE,CAAC;AACpB,MAAM,aAAa,GAAG,MAAM,CAAC;AAC7B,MAAM,eAAe,GAAG,oCAAoC,CAAC;AAC7D,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AACnD,MAAM,YAAY,GAAG,gBAAgB,CAAC;AACtC,MAAM,WAAW,GAAG,sBAAsB,CAAC;AAC3C,MAAM,YAAY,GAAG,0BAA0B,CAAC;AAChD,MAAM,oBAAoB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAC5C;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,iCAAiC,CAAC;AAE7D,MAAM,KAAK,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,IAAI,OAAO,CAAO,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;AAElG,0DAA0D;AAC1D,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAW,EAAE;IACtD,MAAM,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,aAAa,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC;IAC/F,OAAO,UAAU,gBAAgB,cAAc,CAAC;AAClD,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,oBAAoB,GAAG,CAAC,UAAkB,EAAU,EAAE,CAAC;IAC3D,iBAAiB,UAAU,GAAG;IAC9B,0BAA0B,QAAQ,EAAE;IACpC,+BAA+B;IAC/B,+BAA+B;IAC/B,8BAA8B;IAC9B,6BAA6B;IAC7B,yCAAyC;IACzC,8BAA8B;IAC9B,4CAA4C;IAC5C,sFAAsF;IACtF,4HAA4H;CAC7H,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;;;;GAIG;AACH,MAAM,OAAO,aAAa;IACf,QAAQ,CAAwB;IAChC,UAAU,CAAiC;IACpD,QAAQ,CAAoC;IAC5C,SAAS,CAA6C;IAEtD,YAAY,aAAoC,EAAE;QAChD,IAAI,CAAC,QAAQ,GAAG,EAAE,GAAG,UAAU,EAAE,CAAC;QAClC,IAAI,CAAC,UAAU,GAAG,IAAI,8BAA8B,CAAC,QAAQ,EAAE;YAC7D,GAAG,UAAU;YACb,gBAAgB,EAAE,UAAU,CAAC,gBAAgB,IAAI,2BAA2B,EAAE;SAC/E,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IACrB,CAAC;IAED,IAAW,OAAO;QAChB,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QAC1E,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,2DAA2D;IAC3D,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;IAC9B,CAAC;IAED,uEAAuE;IACvE,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;IACxC,CAAC;IAED;;;;OAIG;IACI,KAAK;QACV,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC,CAAC;QAChG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,MAAM;QACV,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;QACjD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;gBACnC,KAAK,EAAE,kBAAkB;gBACzB,IAAI,EAAE,MAAM;gBACZ,mBAAmB,EAAE,IAAI;gBACzB,OAAO,EAAE,CAAC,wBAAwB,CAAC;gBACnC,GAAG,EAAE;oBACH,qBAAqB,EAAE,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAC7D,8BAA8B,EAAE,SAAS,kBAAkB,EAAE;iBAC9D;gBACD,QAAQ;gBACR,OAAO,EAAE;oBACP,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE;oBAC5C,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE;iBAC/C;gBACD,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI;gBAChE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,aAAa;gBACjD,SAAS,EAAE,IAAI;gBACf,YAAY,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI;gBAC/B,kBAAkB,EAAE,EAAE;gBACtB,oFAAoF;gBACpF,+EAA+E;gBAC/E,WAAW,EAAE;oBACX,IAAI,EAAE,CAAC,WAAW,EAAE,WAAW,kBAAkB,kEAAkE,CAAC;oBACpH,UAAU,EAAE,MAAM;oBAClB,SAAS,EAAE,MAAM;oBACjB,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB;oBAC/C,eAAe,EAAE,KAAK;oBACtB,OAAO,EAAE,CAAC;iBACX;aACF,CAAC,CAAC;YACH,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;YACxE,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC;gBACzC,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;aACnF,CAAC,CAAC;YACH,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;YACpC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAC/C,IAAI,OAAO,KAAK,kBAAkB,CAAC,OAAO,EAAE,CAAC;gBAC3C,MAAM,IAAI,KAAK,CAAC,0BAA0B,OAAO,yBAAyB,kBAAkB,CAAC,OAAO,GAAG,CAAC,CAAC;YAC3G,CAAC;YACD,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;YACpC,IAAI,CAAC,QAAQ,GAAG;gBACd,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,WAAW;gBACxC,OAAO,EAAE,QAAQ,CAAC,OAAO;gBACzB,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;gBAC3C,OAAO;gBACP,KAAK,EAAE,kBAAkB;gBACzB,KAAK,EAAE,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE;aAC1C,CAAC;YACF,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YACvD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YAC/B,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,MAAM,IAAI,cAAc,CAAC,CAAC,QAAQ,EAAE,YAAY,CAAC,EAAE,qDAAqD,CAAC,CAAC;YAC5G,CAAC;YACD,MAAM,QAAQ,CAAC;QACjB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,iBAAiB,CAAC,UAAqC;QAClE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;eACzF,UAAU,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC3G,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAC;QAChE,CAAC;QACD,MAAM,MAAM,GAAG;YACb,iCAAiC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG;YACvE,qDAAqD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI;kBACzF,WAAW,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,gCAAgC;YAChF,SAAS,WAAW,iBAAiB;SACtC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACb,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,8BAA8B,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE;YACzF,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,oBAAoB;SAC/C,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YAC1B,yEAAyE;YACzE,MAAM,WAAW,GAAG,GAAG,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC;iBACjE,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YACxF,MAAM,IAAI,KAAK,CAAC,oDAAoD,UAAU,CAAC,QAAQ,UAAU,MAAM,CAAC,QAAQ,MAAM,WAAW,EAAE,CAAC,CAAC;QACvI,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC;QAC1F,MAAM,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;QACrD,IAAI,CAAC,KAAK,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,sEAAsE,CAAC,CAAC;QACjI,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;QAC1B,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;QAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,QAAQ;YAAE,MAAM,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QACpD,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,aAAa,CAAC,WAAmB;QACrC,IAAI,MAAM,GAAG,MAAM,CAAC;QACpB,IAAI,GAAG,GAAG,YAAY,CAAC;QACvB,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,WAAW,EAAE,CAAC;YAChC,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;YACpC,MAAM,IAAI,CAAC,UAAU,CAAC,sBAAsB,EAAE,CAAC;YAC/C,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC;YACjD,IAAI,MAAM,KAAK,WAAW;gBAAE,MAAM;YAClC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,IAAI,CAAC;oBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC;wBAClD,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,iBAAiB,EAAE,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM;qBAC1F,CAAC,CAAC;oBACH,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG;wBAAE,OAAO;oBACpC,GAAG,GAAG,UAAU,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACpC,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,GAAG,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC/D,CAAC;YACH,CAAC;YACD,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,+BAA+B,IAAI,CAAC,UAAU,CAAC,gBAAgB,KAAK,CAAC;QAClI,MAAM,IAAI,KAAK,CAAC,UAAU,MAAM,YAAY,MAAM,SAAS,GAAG,kBAAkB,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACxH,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,QAAgB;QACjC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC;YAClD,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,iBAAiB,EAAE,OAAO,EAAE,EAAE,eAAe,EAAE,QAAQ,EAAE,EAAE,cAAc,EAAE,CAAC,GAAG,CAAC;SACrG,CAAC,CAAC;QACH,MAAM,OAAO,GAAY,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9G,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACvG,OAAO,OAAO,CAAC;IACjB,CAAC;CACF"}

package/dist_ts/classes.gitlabseed.d.ts

@@ -0,0 +1,13 @@
+import type { GitlabFixture } from './classes.gitlabfixture.js';
+import type { IGitlabSeedManifest, IGitlabSeedSpec } from './interfaces.gitlabseed.js';
+/** Rejects inconsistent specs before the first mutation. */
+export declare const validateGitlabSeedSpec: (specArg: IGitlabSeedSpec) => void;
+/**
+ * Seeds a running {@link GitlabFixture} through GitLab's documented REST API,
+ * then reads everything back into a ground-truth manifest.
+ */
+export declare class GitlabSeedBuilder {
+    #private;
+    constructor(fixtureArg: GitlabFixture);
+    apply(specArg: IGitlabSeedSpec): Promise<IGitlabSeedManifest>;
+}