@merchantduo/code 0.3.0-beta.0 → 0.3.0-beta.2

package/dist/provision/planner.js

@@ -1,51 +0,0 @@
-const sourceMissing = (snapshot, input) => !snapshot.workspace.magentoRoot && (!input.source || input.source === "existing");
-const databaseMissing = (snapshot, input) => !input.database && snapshot.database.dumps.length !== 1;
-/** Deterministic planner. It has no process or filesystem side effects. */
-export function createProvisionPlan(snapshot, input) {
-    const blocked = [];
-    const rationale = [];
-    const actions = [];
-    const environment = input.environment;
-    if (!environment)
-        blocked.push("Select --env local or --env warden.");
-    if (sourceMissing(snapshot, input))
-        blocked.push("Provide --source existing, a Git URL, archive path, or HTTPS archive URL.");
-    if (databaseMissing(snapshot, input))
-        blocked.push("Provide --database current, a dump path, or an HTTPS dump URL.");
-    if (input.database === "current" && !snapshot.database.envConfigured)
-        blocked.push("--database current requires an existing usable Magento database configuration.");
-    if (environment === "warden" && !snapshot.environments.warden.available)
-        blocked.push("Warden is not installed or available on PATH.");
-    if (environment === "local" && (!snapshot.environments.local.php || !snapshot.environments.local.composer || !snapshot.environments.local.mysql))
-        blocked.push("Local provisioning requires PHP, Composer, and the MySQL client.");
-    if (environment === "local" && snapshot.environments.local.activeServers.length === 0)
-        blocked.push("Start nginx or Apache before local provisioning.");
-    if (environment === "local" && snapshot.environments.local.activeServers.length > 1 && !input.localDomain)
-        blocked.push("Both nginx and Apache are active; choose a local domain/server interactively.");
-    if (blocked.length)
-        return { actions, rationale, blocked, requiresSudo: false };
-    if (!snapshot.workspace.magentoRoot && input.source && input.source !== "existing")
-        actions.push({ type: "acquire-source", source: input.source });
-    actions.push({ type: "install-dependencies" });
-    if (environment === "warden" && !snapshot.environments.warden.running)
-        actions.push({ type: "start-warden" });
-    const database = input.database ?? (snapshot.database.dumps.length === 1 ? `dump:${snapshot.database.dumps[0]}` : undefined);
-    if (environment === "local" && !snapshot.database.envConfigured)
-        actions.push({ type: "configure-database" });
-    if (database && database !== "current")
-        actions.push({ type: "import-database", database });
-    actions.push({ type: "magento-setup", command: "app:config:import" }, { type: "magento-setup", command: "setup:upgrade" }, { type: "magento-setup", command: "cache:clean" }, { type: "magento-setup", command: "indexer:reindex" }, { type: "magento-setup", command: "maintenance:disable" });
-    const vhost = snapshot.environments.local.vhost;
-    if (environment === "local" && !vhost) {
-        const server = snapshot.environments.local.activeServers[0];
-        const domain = input.localDomain ?? `${snapshot.workspace.root.split("/").filter(Boolean).pop().replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.test`;
-        actions.push({ type: "configure-web-server", server, domain });
-        rationale.push(`Create a minimal ${server} virtual host for ${domain}.`);
-    }
-    actions.push({ type: "verify-storefront", url: environment === "warden" ? snapshot.environments.warden.domain : vhost?.domain ?? input.localDomain });
-    rationale.push("Composer uses the lock file; Magento deployment mode is preserved.");
-    return { actions, rationale, blocked, requiresSudo: actions.some((action) => action.type === "configure-web-server") };
-}
-export function unresolvedInputs(snapshot, input) {
-    return createProvisionPlan(snapshot, input).blocked;
-}

package/dist/provision/runner.d.ts

@@ -1,35 +0,0 @@
-import type { CommandExecutor } from "#environments/executor";
-import type { ProvisionAction, ProvisionEnvironment, ProvisionInput } from "#provision/model";
-export type ProvisionRunner = {
-    run(argv: string[], options?: {
-        cwd?: string;
-        input?: string;
-    }): Promise<{
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-    }>;
-};
-export declare class BackendProvisionRunner implements ProvisionRunner {
-    private readonly backend;
-    constructor(backend: CommandExecutor);
-    run(argv: string[], options?: {
-        cwd?: string;
-        input?: string;
-    }): Promise<import("#environments/executor").CommandResult>;
-}
-export declare function validateArchiveEntry(entry: string): boolean;
-export declare function vhostConfig(server: "nginx" | "apache", projectRoot: string, domain: string): string;
-export declare class DefaultProvisionExecutor {
-    private readonly runner;
-    private readonly root;
-    private readonly environment;
-    private readonly magentoRunner;
-    constructor(runner: ProvisionRunner, root: string, environment: ProvisionEnvironment, magentoRunner?: ProvisionRunner);
-    execute(action: ProvisionAction, input: ProvisionInput): Promise<void>;
-    private acquire;
-    private importDatabase;
-    private configureVhost;
-    private verify;
-    private must;
-}

package/dist/provision/runner.js

@@ -1,98 +0,0 @@
-import { mkdir, rm, stat } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-export class BackendProvisionRunner {
-    backend;
-    constructor(backend) {
-        this.backend = backend;
-    }
-    run(argv, options = {}) { return this.backend.run(argv, { input: options.input }); }
-}
-export function validateArchiveEntry(entry) {
-    return entry.length > 0 && !entry.startsWith("/") && !entry.split(/[\\/]+/).includes("..");
-}
-export function vhostConfig(server, projectRoot, domain) {
-    if (!/^[a-z0-9-]+\.test$/i.test(domain))
-        throw new Error("Local domain must be a sanitized .test hostname");
-    const root = join(resolve(projectRoot), "pub");
-    return server === "nginx" ? `server { listen 80; server_name ${domain}; root ${root}; index index.php; location / { try_files $uri $uri/ /index.php?$args; } location ~ \\.php$ { try_files $uri =404; fastcgi_pass unix:/run/php/php-fpm.sock; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; } }\n` : `<VirtualHost *:80>\n  ServerName ${domain}\n  DocumentRoot ${root}\n  <Directory ${root}>\n    AllowOverride All\n    Require all granted\n  </Directory>\n</VirtualHost>\n`;
-}
-export class DefaultProvisionExecutor {
-    runner;
-    root;
-    environment;
-    magentoRunner;
-    constructor(runner, root, environment, magentoRunner = runner) {
-        this.runner = runner;
-        this.root = root;
-        this.environment = environment;
-        this.magentoRunner = magentoRunner;
-    }
-    async execute(action, input) {
-        switch (action.type) {
-            case "acquire-source": return this.acquire(action.source);
-            case "install-dependencies": return this.must(["composer", "install", "--no-interaction", "--prefer-dist", "--no-progress"], this.magentoRunner);
-            case "start-warden": return this.must(["warden", "env", "config"]).then(() => this.must(["warden", "env", "start"]));
-            case "import-database": return this.importDatabase(action.database);
-            case "configure-database": throw new Error("Database configuration is required but no safe credential source was supplied. Add app/etc/env.php or use a current configured database.");
-            case "magento-setup":
-                if (action.command === "app:config:import") {
-                    const result = await this.magentoRunner.run(["bin/magento", action.command, "--no-interaction"], { cwd: this.root });
-                    if (result.exitCode !== 0 && !/does not exist|Nothing to import/i.test(result.stderr + result.stdout))
-                        throw new Error(result.stderr || result.stdout);
-                    return;
-                }
-                return this.must(["bin/magento", action.command, "--no-interaction"], this.magentoRunner);
-            case "configure-web-server": return this.configureVhost(action.server, action.domain);
-            case "verify-storefront": return this.verify(action.url);
-        }
-    }
-    async acquire(source) {
-        const entries = await stat(this.root).then(() => import("node:fs/promises").then(({ readdir }) => readdir(this.root))).catch(() => []);
-        if (entries.length)
-            throw new Error("Refusing to acquire source into a non-empty non-Magento directory.");
-        if (source.startsWith("git:"))
-            return this.must(["git", "clone", source.slice(4), "."]);
-        const location = source.replace(/^(archive|https):/, "");
-        const home = process.env.MERCHANTDUO_HOME ?? join(process.env.XDG_STATE_HOME ?? "/tmp", "merchantduo");
-        const stage = join(home, "provisions", `${Date.now()}-${basename(location).replace(/[^a-z0-9._-]/gi, "-")}`);
-        await mkdir(stage, { recursive: true });
-        try {
-            const archive = source.startsWith("https:") ? join(stage, "source.archive") : resolve(location);
-            if (source.startsWith("https:"))
-                await this.must(["curl", "--fail", "--location", "--output", archive, location]);
-            const listed = await this.runner.run(["tar", "-tzf", archive]);
-            if (listed.exitCode !== 0 || listed.stdout.split("\n").filter(Boolean).some((entry) => !validateArchiveEntry(entry)))
-                throw new Error("Archive is invalid or contains unsafe paths.");
-            await this.must(["tar", "-xzf", archive, "-C", this.root, "--strip-components=1"]);
-            const magento = await this.runner.run(["sh", "-lc", "test -f composer.json && (test -x bin/magento || grep -q 'magento/' composer.json)"], { cwd: this.root });
-            if (magento.exitCode !== 0)
-                throw new Error("Extracted archive does not contain a Magento root.");
-        }
-        finally {
-            await rm(stage, { recursive: true, force: true });
-        }
-    }
-    async importDatabase(database) {
-        const source = database.replace(/^(dump|https):/, "");
-        if (this.environment === "warden")
-            return this.must(["warden", "db", "import", source]);
-        if (database.startsWith("https:"))
-            throw new Error("Download the local database dump before local import; database credentials are never accepted as CLI arguments.");
-        return this.must(["sh", "-lc", `${source.endsWith(".gz") ? "gzip -dc --" : "cat --"} "$1" | mysql`, "merchantduo-db-import", source]);
-    }
-    async configureVhost(server, domain) {
-        const config = vhostConfig(server, this.root, domain);
-        const file = server === "nginx" ? `/etc/nginx/sites-available/${domain}` : `/etc/apache2/sites-available/${domain}.conf`;
-        const encoded = Buffer.from(config).toString("base64");
-        await this.must(["sudo", "sh", "-lc", `echo ${encoded} | base64 -d > ${file}`]);
-        if (server === "nginx")
-            await this.must(["sudo", "sh", "-lc", `ln -sfn ${file} /etc/nginx/sites-enabled/${domain} && nginx -t && systemctl reload nginx`]);
-        else
-            await this.must(["sudo", "sh", "-lc", `a2ensite ${domain}.conf && apachectl configtest && systemctl reload apache2`]);
-        await this.must(["sudo", "sh", "-lc", `grep -qE '^[[:space:]]*127\\.0\\.0\\.1[[:space:]].*\\b${domain}\\b' /etc/hosts || echo '127.0.0.1 ${domain}' >> /etc/hosts`]);
-    }
-    async verify(url) { if (url)
-        await this.must(["curl", "--fail", "--location", "--max-time", "20", `http://${url}`]); }
-    async must(argv, runner = this.runner) { const result = await runner.run(argv, { cwd: this.root }); if (result.exitCode !== 0)
-        throw new Error(`${argv.join(" ")} failed: ${result.stderr || result.stdout}`); }
-}