@sonarsource/marketing-cli 1.0.0

package/dist/netlify.js

@@ -0,0 +1,199 @@
+import { CliError } from './errors.js';
+const NETLIFY_API_BASE = 'https://api.netlify.com/api/v1';
+/**
+ * Fetch env vars for a Netlify site using raw `fetch`.
+ *
+ * We bypass `@netlify/api`'s `getSiteEnvVars` because of a bug in the
+ * `@netlify/open-api` spec that doubles the `/api/v1` path prefix,
+ * producing a 404. See ADR-0002 and https://github.com/netlify/open-api/issues/579
+ */
+async function fetchSiteEnvVars(token, siteId) {
+    const url = `${NETLIFY_API_BASE}/sites/${encodeURIComponent(siteId)}/env`;
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/json',
+        },
+    });
+    assertOk(response, 'GET', url);
+    return (await response.json());
+}
+/**
+ * Fetch the `account_id` for a Netlify site.
+ *
+ * Write operations on env vars (PATCH, DELETE) must go through the
+ * account-level endpoint `/accounts/{account_id}/env/…`, not the
+ * site-level endpoint. See ADR-0002.
+ */
+async function fetchSiteAccountId(token, siteId) {
+    const url = `${NETLIFY_API_BASE}/sites/${encodeURIComponent(siteId)}`;
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/json',
+        },
+    });
+    assertOk(response, 'GET', url);
+    const body = (await response.json());
+    if (!body.account_id) {
+        throw new CliError(`Could not resolve account_id for Netlify site "${siteId}".`);
+    }
+    return body.account_id;
+}
+/**
+ * Fetch env vars from the production Netlify site and extract:
+ * - `secureKey` (the delivery secure key)
+ * - `productionEnvironmentId` (for validation against config)
+ */
+export async function fetchProductionVars(token, siteId, envVarNames) {
+    const vars = await fetchSiteEnvVars(token, siteId);
+    const secureKey = requireProductionVar(vars, envVarNames.secureKey);
+    const productionEnvironmentId = requireProductionVar(vars, envVarNames.environmentId);
+    return { secureKey, productionEnvironmentId };
+}
+/**
+ * Find a var on the production site and return its production/all value,
+ * or throw with a clear message.
+ */
+function requireProductionVar(vars, varName) {
+    const envVar = vars.find((v) => v.key === varName);
+    if (!envVar) {
+        throw new CliError(`Env var "${varName}" not found on the production Netlify site.`);
+    }
+    const value = getProductionValue(envVar);
+    if (!value) {
+        throw new CliError(`Env var "${varName}" has no production/all value on the production Netlify site.`);
+    }
+    return value;
+}
+/**
+ * Branch-context guard: resolve a var's value for a specific branch.
+ *
+ * 1. Look for `context: "branch"` with `context_parameter === branch`.
+ * 2. If found → use that value (branch-specific).
+ * 3. If not found → use the `context: "all"` value (global fallback).
+ *
+ * A global fallback is **never** treated as branch-specific.
+ */
+function resolveVarForBranch(envVar, branch) {
+    if (branch) {
+        const branchEntry = envVar.values.find((v) => v.context === 'branch' && v.context_parameter === branch);
+        if (branchEntry) {
+            return { value: branchEntry.value, isBranchSpecific: true };
+        }
+    }
+    // Fall back to global/all
+    const allEntry = envVar.values.find((v) => v.context === 'all');
+    if (allEntry) {
+        return { value: allEntry.value, isBranchSpecific: false };
+    }
+    // Try production context as fallback
+    const prodEntry = envVar.values.find((v) => v.context === 'production');
+    if (prodEntry) {
+        return { value: prodEntry.value, isBranchSpecific: false };
+    }
+    return undefined;
+}
+/**
+ * Assert a Netlify API response is successful; throw {@link CliError} on
+ * auth failures or unexpected status codes.
+ */
+function assertOk(response, method, url) {
+    if (response.status === 401 || response.status === 403) {
+        throw new CliError('Netlify authentication failed. Run `netlify login` or set NETLIFY_AUTH_TOKEN.');
+    }
+    if (!response.ok) {
+        throw new CliError(`Netlify API error: ${response.status} ${response.statusText} (${method} ${url})`);
+    }
+}
+/**
+ * Get the production or "all" context value from a Netlify env var.
+ */
+function getProductionValue(envVar) {
+    const prod = envVar.values.find((v) => v.context === 'production');
+    if (prod)
+        return prod.value;
+    const all = envVar.values.find((v) => v.context === 'all');
+    return all?.value;
+}
+/**
+ * Fetch all env vars for a Netlify site once and return a {@link BranchVars}
+ * object whose read methods operate on the cached snapshot and whose write
+ * methods hit the API then optimistically update the cache.
+ */
+export async function fetchBranchVars(token, siteId) {
+    // Fetch env vars and account_id in parallel — the account_id is needed
+    // because write operations use the account-level API endpoint.
+    const [vars, accountId] = await Promise.all([
+        fetchSiteEnvVars(token, siteId),
+        fetchSiteAccountId(token, siteId),
+    ]);
+    return {
+        has(key, branch) {
+            const envVar = vars.find((v) => v.key === key);
+            if (!envVar)
+                return false;
+            return envVar.values.some((v) => v.context === 'branch' && v.context_parameter === branch);
+        },
+        resolve(key, branch) {
+            const envVar = vars.find((v) => v.key === key);
+            if (!envVar)
+                return undefined;
+            return resolveVarForBranch(envVar, branch);
+        },
+        async set(key, branch, value) {
+            const url = `${NETLIFY_API_BASE}/accounts/${encodeURIComponent(accountId)}/env/${encodeURIComponent(key)}?site_id=${encodeURIComponent(siteId)}`;
+            const response = await fetch(url, {
+                method: 'PATCH',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    context: 'branch',
+                    context_parameter: branch,
+                    value,
+                }),
+            });
+            assertOk(response, 'PATCH', url);
+            // Optimistic cache update — replace the cached var with the API response
+            const updated = (await response.json());
+            const idx = vars.findIndex((v) => v.key === key);
+            if (idx >= 0) {
+                vars[idx] = updated;
+            }
+            else {
+                vars.push(updated);
+            }
+        },
+        async delete(key, branch) {
+            const envVar = vars.find((v) => v.key === key);
+            if (!envVar)
+                return;
+            const branchValue = envVar.values.find((v) => v.context === 'branch' && v.context_parameter === branch);
+            if (!branchValue)
+                return;
+            const url = `${NETLIFY_API_BASE}/accounts/${encodeURIComponent(accountId)}/env/${encodeURIComponent(key)}/value/${encodeURIComponent(branchValue.id)}?site_id=${encodeURIComponent(siteId)}`;
+            const response = await fetch(url, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            assertOk(response, 'DELETE', url);
+            // Optimistic cache update — remove the deleted value
+            envVar.values = envVar.values.filter((v) => v.id !== branchValue.id);
+        },
+    };
+}
+/**
+ * Resolve the Netlify auth token from the environment.
+ * Throws with actionable guidance when missing.
+ */
+export function resolveNetlifyToken() {
+    const token = process.env['NETLIFY_AUTH_TOKEN'];
+    if (!token) {
+        throw new CliError('Netlify authentication failed. Run `netlify login` or set NETLIFY_AUTH_TOKEN.');
+    }
+    return token;
+}

package/dist/project.d.ts

@@ -0,0 +1,21 @@
+/** Canonical content for `Migrations/package.json`. */
+export declare const MIGRATIONS_PACKAGE_JSON: {
+    readonly name: "kontent-migrations";
+    readonly private: true;
+    readonly type: "module";
+};
+/**
+ * Assert that `<migrationsFolder>/package.json` sets `"type": "module"`.
+ *
+ * Compiled migration `.js` files live in the migrations folder.  Without a
+ * neighbouring `package.json` that sets `"type": "module"`, Node treats them
+ * as CommonJS, and `@kontent-ai/data-ops` cannot load them via dynamic
+ * `import()`.
+ */
+export declare function requireMigrationsEsm(migrationsFolder: string): void;
+/**
+ * Write `Migrations/package.json` if it does not already exist.
+ *
+ * Returns `true` when the file was created, `false` when it already existed.
+ */
+export declare function ensureMigrationsPackageJson(migrationsFolder: string): boolean;

package/dist/project.js

@@ -0,0 +1,57 @@
+import { accessSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CliError } from './errors.js';
+/** Canonical content for `Migrations/package.json`. */
+export const MIGRATIONS_PACKAGE_JSON = {
+    name: 'kontent-migrations',
+    private: true,
+    type: 'module',
+};
+/**
+ * Assert that `<migrationsFolder>/package.json` sets `"type": "module"`.
+ *
+ * Compiled migration `.js` files live in the migrations folder.  Without a
+ * neighbouring `package.json` that sets `"type": "module"`, Node treats them
+ * as CommonJS, and `@kontent-ai/data-ops` cannot load them via dynamic
+ * `import()`.
+ */
+export function requireMigrationsEsm(migrationsFolder) {
+    const pkgPath = join(migrationsFolder, 'package.json');
+    let raw;
+    try {
+        raw = readFileSync(pkgPath, 'utf8');
+    }
+    catch {
+        throw new CliError(`No Migrations/package.json found in ${migrationsFolder}. ` +
+            `Run \`marketing init\` to scaffold the required project files.`);
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(raw);
+    }
+    catch {
+        throw new CliError(`Migrations/package.json in ${migrationsFolder} contains invalid JSON.`);
+    }
+    if (typeof pkg !== 'object' ||
+        pkg === null ||
+        pkg['type'] !== 'module') {
+        throw new CliError(`Migrations/package.json must set "type": "module" for compiled migrations to load correctly. ` +
+            `Run \`marketing init\` to fix this.`);
+    }
+}
+/**
+ * Write `Migrations/package.json` if it does not already exist.
+ *
+ * Returns `true` when the file was created, `false` when it already existed.
+ */
+export function ensureMigrationsPackageJson(migrationsFolder) {
+    const pkgPath = join(migrationsFolder, 'package.json');
+    try {
+        accessSync(pkgPath);
+        return false;
+    }
+    catch {
+        writeFileSync(pkgPath, JSON.stringify(MIGRATIONS_PACKAGE_JSON, null, 2) + '\n');
+        return true;
+    }
+}

package/dist/status.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Load `Migrations/status.json` (or return empty `{}`).
+ */
+export declare function loadStatusJson(cwd: string): Record<string, unknown>;
+/**
+ * Write `Migrations/status.json`.
+ */
+export declare function writeStatusJson(cwd: string, status: Record<string, unknown>): void;

package/dist/status.js

@@ -0,0 +1,24 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { MIGRATIONS_FOLDER } from './branches.js';
+/**
+ * Load `Migrations/status.json` (or return empty `{}`).
+ */
+export function loadStatusJson(cwd) {
+    const filePath = join(cwd, MIGRATIONS_FOLDER, 'status.json');
+    try {
+        const raw = readFileSync(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Write `Migrations/status.json`.
+ */
+export function writeStatusJson(cwd, status) {
+    const filePath = join(cwd, MIGRATIONS_FOLDER, 'status.json');
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(status, null, 2) + '\n', 'utf8');
+}

package/dist/test/handlers.d.ts

@@ -0,0 +1,18 @@
+import type { NetlifyEnvVar } from '../netlify.js';
+export interface NetlifyFixture {
+    /** site_id → env vars mapping */
+    sites: Record<string, NetlifyEnvVar[]>;
+    /** site_id → account_id mapping */
+    siteAccounts: Record<string, string>;
+}
+/**
+ * Factory that creates MSW handlers for the Netlify env-var endpoints.
+ *
+ * Read (list) uses the site-level endpoint:
+ *   GET /api/v1/sites/{site_id}/env
+ *
+ * Write operations use the account-level endpoints (per the Netlify API spec):
+ *   PATCH  /api/v1/accounts/{account_id}/env/{key}?site_id=…
+ *   DELETE /api/v1/accounts/{account_id}/env/{key}/value/{id}?site_id=…
+ */
+export declare function createNetlifyHandlers(fixture: NetlifyFixture): import("msw").HttpHandler[];

package/dist/test/handlers.js

@@ -0,0 +1,102 @@
+import { http, HttpResponse } from 'msw';
+/**
+ * Factory that creates MSW handlers for the Netlify env-var endpoints.
+ *
+ * Read (list) uses the site-level endpoint:
+ *   GET /api/v1/sites/{site_id}/env
+ *
+ * Write operations use the account-level endpoints (per the Netlify API spec):
+ *   PATCH  /api/v1/accounts/{account_id}/env/{key}?site_id=…
+ *   DELETE /api/v1/accounts/{account_id}/env/{key}/value/{id}?site_id=…
+ */
+export function createNetlifyHandlers(fixture) {
+    /** Resolve site_id from either the query string or the fixture's account mapping. */
+    function findSiteForAccount(accountId, requestUrl) {
+        // Extract site_id from query string
+        const url = new URL(requestUrl);
+        const siteId = url.searchParams.get('site_id');
+        if (siteId)
+            return siteId;
+        // Reverse-lookup from fixture
+        return Object.entries(fixture.siteAccounts).find(([, acct]) => acct === accountId)?.[0];
+    }
+    return [
+        // GET site info (for account_id resolution)
+        http.get('https://api.netlify.com/api/v1/sites/:siteId', ({ params, request }) => {
+            const siteId = params['siteId'];
+            // Only respond to bare site info requests — not /sites/:id/env
+            const url = new URL(request.url);
+            if (url.pathname !== `/api/v1/sites/${siteId}`) {
+                return undefined; // pass through to next handler
+            }
+            const accountId = fixture.siteAccounts[siteId];
+            if (!accountId) {
+                return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+            }
+            return HttpResponse.json({ id: siteId, account_id: accountId });
+        }),
+        // GET all env vars for a site
+        http.get('https://api.netlify.com/api/v1/sites/:siteId/env', ({ params }) => {
+            const siteId = params['siteId'];
+            const vars = fixture.sites[siteId];
+            if (!vars) {
+                return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+            }
+            return HttpResponse.json(vars);
+        }),
+        // PATCH (set/update) an env var value — account-level endpoint
+        http.patch('https://api.netlify.com/api/v1/accounts/:accountId/env/:key', async ({ params, request }) => {
+            const accountId = params['accountId'];
+            const key = decodeURIComponent(params['key']);
+            const siteId = findSiteForAccount(accountId, request.url);
+            if (!siteId) {
+                return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+            }
+            const vars = fixture.sites[siteId];
+            if (!vars) {
+                return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+            }
+            const body = (await request.json());
+            // Find or create the var
+            let envVar = vars.find((v) => v.key === key);
+            if (!envVar) {
+                envVar = { key, scopes: ['builds'], values: [] };
+                vars.push(envVar);
+            }
+            // Upsert the value
+            const existing = envVar.values.find((v) => v.context === body.context && v.context_parameter === body.context_parameter);
+            if (existing) {
+                existing.value = body.value;
+            }
+            else {
+                envVar.values.push({
+                    id: `val-${Date.now()}`,
+                    value: body.value,
+                    context: body.context,
+                    context_parameter: body.context_parameter,
+                });
+            }
+            return HttpResponse.json(envVar);
+        }),
+        // DELETE a specific env var value by value ID — account-level endpoint
+        http.delete('https://api.netlify.com/api/v1/accounts/:accountId/env/:key/value/:valueId', ({ params, request }) => {
+            const accountId = params['accountId'];
+            const key = decodeURIComponent(params['key']);
+            const valueId = params['valueId'];
+            const siteId = findSiteForAccount(accountId, request.url);
+            if (!siteId) {
+                return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+            }
+            const vars = fixture.sites[siteId];
+            if (!vars) {
+                return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+            }
+            const envVar = vars.find((v) => v.key === key);
+            if (!envVar) {
+                return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+            }
+            envVar.values = envVar.values.filter((v) => v.id !== valueId);
+            return new HttpResponse(null, { status: 204 });
+        }),
+    ];
+}

package/dist/test/server.d.ts

@@ -0,0 +1 @@
+export declare const server: import("msw/node").SetupServer;

package/dist/test/server.js

@@ -0,0 +1,2 @@
+import { setupServer } from 'msw/node';
+export const server = setupServer();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@sonarsource/marketing-cli",
+  "version": "1.0.0",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "marketing": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/migrations.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "build": "tsc -p tsconfig.build.json && cp src/migration.template dist/",
+    "prepack": "yarn build",
+    "ts:ci": "tsc --noEmit",
+    "format": "prettier -w -c .",
+    "format:ci": "prettier -c .",
+    "lint": "eslint . --max-warnings 0",
+    "lint:ci": "eslint . --max-warnings 0 -f json -o ./coverage/eslint.json",
+    "test": "vitest",
+    "test:ci": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.7.0",
+    "@kontent-ai/data-ops": "^2.8.0",
+    "@kontent-ai/management-sdk": "8.5.2",
+    "commander": "15.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "26.1.1",
+    "@vitest/coverage-v8": "4.1.10",
+    "@vitest/eslint-plugin": "1.6.21",
+    "eslint": "10.6.0",
+    "eslint-config-prettier": "10.1.8",
+    "globals": "17.7.0",
+    "jiti": "2.7.0",
+    "msw": "^2.15.0",
+    "prettier": "3.9.4",
+    "prettier-plugin-organize-imports": "4.3.0",
+    "tsx": "4.23.0",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.63.0",
+    "vitest": "4.1.10"
+  }
+}