dropsh 0.0.1

package/dist/src/core/auth/oauth2.js

@@ -0,0 +1,64 @@
+import { AuthError, HttpError } from "../../errors.js";
+function requireString(cfg, key) {
+    const v = cfg[key];
+    if (typeof v !== "string" || v.length === 0) {
+        throw new AuthError(`${cfg.type} auth requires ${key}`);
+    }
+    return v;
+}
+export function createOAuth2Auth(cfg, deps) {
+    const now = deps.now ?? Date.now;
+    const clientId = requireString(cfg, "client_id");
+    const clientSecret = requireString(cfg, "client_secret");
+    const tokenUrl = typeof cfg.token_url === "string" ? cfg.token_url : `${deps.baseUrl.replace(/\/$/, "")}/oauth/token`;
+    const params = new URLSearchParams({
+        client_id: clientId,
+        client_secret: clientSecret,
+    });
+    if (cfg.type === "oauth2_password") {
+        params.set("grant_type", "password");
+        params.set("username", requireString(cfg, "username"));
+        params.set("password", requireString(cfg, "password"));
+        if (typeof cfg.scope === "string")
+            params.set("scope", cfg.scope);
+    }
+    else if (cfg.type === "oauth2_client_credentials") {
+        params.set("grant_type", "client_credentials");
+        if (typeof cfg.scope === "string")
+            params.set("scope", cfg.scope);
+    }
+    else {
+        throw new AuthError(`Unsupported oauth2 grant: ${cfg.type}`);
+    }
+    let cached = null;
+    async function fetchToken() {
+        try {
+            const res = await deps.http.send({
+                method: "POST",
+                url: tokenUrl,
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: params.toString(),
+            });
+            const body = JSON.parse(res.body);
+            if (typeof body.access_token !== "string") {
+                throw new AuthError("Token endpoint returned no access_token");
+            }
+            const ttlSec = typeof body.expires_in === "number" ? body.expires_in : 3600;
+            return { token: body.access_token, expiresAt: now() + ttlSec * 1000 - 5000 };
+        }
+        catch (err) {
+            if (err instanceof HttpError)
+                throw new AuthError(`Token request failed: HTTP ${err.status}`, { body: err.body });
+            if (err instanceof AuthError)
+                throw err;
+            throw new AuthError(`Token request failed: ${err.message}`);
+        }
+    }
+    return {
+        async apply(req) {
+            if (!cached || cached.expiresAt <= now())
+                cached = await fetchToken();
+            return { ...req, headers: { ...(req.headers ?? {}), Authorization: `Bearer ${cached.token}` } };
+        },
+    };
+}

package/dist/src/core/auth/token-store.js

@@ -0,0 +1,26 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function hostnameFromUrl(baseUrl) {
+    return new URL(baseUrl).hostname;
+}
+export function defaultTokenDir() {
+    return join(homedir(), ".config", "drupal-cli");
+}
+export async function readToken(baseUrl, dir) {
+    const tokenDir = dir ?? defaultTokenDir();
+    const tokenPath = join(tokenDir, `${hostnameFromUrl(baseUrl)}.json`);
+    try {
+        const raw = await readFile(tokenPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeToken(baseUrl, token, dir) {
+    const tokenDir = dir ?? defaultTokenDir();
+    await mkdir(tokenDir, { recursive: true });
+    const tokenPath = join(tokenDir, `${hostnameFromUrl(baseUrl)}.json`);
+    await writeFile(tokenPath, JSON.stringify(token, null, 2), { encoding: "utf8", mode: 0o600 });
+}

package/dist/src/core/auth/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/cache/file-store.js

@@ -0,0 +1,38 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export function createFileStore(opts) {
+    function resolve(rel) {
+        return join(opts.rootDir, rel);
+    }
+    return {
+        async read(relPath) {
+            const abs = resolve(relPath);
+            let raw;
+            try {
+                raw = await readFile(abs, "utf8");
+            }
+            catch {
+                return undefined;
+            }
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                opts.warn(`warning: cache file ${abs} was unreadable and has been refetched`);
+                return undefined;
+            }
+        },
+        async write(relPath, value) {
+            const abs = resolve(relPath);
+            const tmp = `${abs}.tmp`;
+            try {
+                await mkdir(dirname(abs), { recursive: true });
+                await writeFile(tmp, JSON.stringify(value, null, 2), "utf8");
+                await rename(tmp, abs);
+            }
+            catch (err) {
+                opts.warn(`warning: could not update cache at ${abs}: ${err.message}`);
+            }
+        },
+    };
+}

package/dist/src/core/cli/output.js

@@ -0,0 +1,20 @@
+import { CliError } from "../../errors.js";
+export function createOutput(opts) {
+    return {
+        emit(value) {
+            opts.stdout(`${JSON.stringify(value)}\n`);
+        },
+        fail(err) {
+            const payload = err instanceof CliError
+                ? { error: { code: err.code, message: err.message, details: err.details } }
+                : {
+                    error: {
+                        code: "E_UNKNOWN",
+                        message: err.message ?? String(err),
+                        details: {},
+                    },
+                };
+            opts.stderr(`${JSON.stringify(payload)}\n`);
+        },
+    };
+}

package/dist/src/core/config.js

@@ -0,0 +1,36 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ConfigError } from "../errors.js";
+function isRecord(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+export async function loadConfig(filePath) {
+    let mod;
+    try {
+        mod = await import(pathToFileURL(resolve(filePath)).href);
+    }
+    catch (err) {
+        throw new ConfigError(`Cannot load config file: ${filePath}`, { cause: String(err) });
+    }
+    const raw = mod.default;
+    if (!isRecord(raw))
+        throw new ConfigError("Config default export must be an object");
+    const site = raw.site;
+    if (!isRecord(site))
+        throw new ConfigError("site section missing");
+    if (typeof site.base_url !== "string" || site.base_url.length === 0)
+        throw new ConfigError("site.base_url required");
+    const defaults = isRecord(raw.defaults) ? raw.defaults : {};
+    const plugins = Array.isArray(raw.plugins) ? raw.plugins : [];
+    return {
+        site: {
+            base_url: site.base_url,
+            jsonapi_prefix: typeof site.jsonapi_prefix === "string" ? site.jsonapi_prefix : "/jsonapi",
+        },
+        defaults: {
+            dry_run: defaults.dry_run === true,
+            timeout_ms: typeof defaults.timeout_ms === "number" ? defaults.timeout_ms : 30000,
+        },
+        plugins,
+    };
+}

package/dist/src/core/http.js

@@ -0,0 +1,69 @@
+import { HttpError } from "../errors.js";
+const RETRY_STATUSES = new Set([502, 503, 504, 408, 429]);
+export function createHttpClient(opts = {}) {
+    const f = opts.fetch ?? fetch;
+    const maxRetries = opts.maxRetries ?? 3;
+    const retryDelayMs = opts.retryDelayMs ?? 300;
+    async function attempt(req) {
+        const controller = new AbortController();
+        const timeout = opts.timeoutMs ? setTimeout(() => controller.abort(), opts.timeoutMs) : null;
+        try {
+            const init = {
+                method: req.method,
+                signal: controller.signal,
+            };
+            if (req.headers !== undefined)
+                init.headers = req.headers;
+            if (req.body !== undefined)
+                init.body = req.body;
+            const res = await f(req.url, init);
+            const text = await res.text();
+            const headers = {};
+            for (const [k, v] of res.headers.entries())
+                headers[k] = v;
+            return { status: res.status, headers, body: text };
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    }
+    async function sleep(ms) {
+        if (ms <= 0)
+            return;
+        await new Promise((r) => setTimeout(r, ms));
+    }
+    return {
+        async send(req) {
+            let lastErr = null;
+            for (let attemptIdx = 0; attemptIdx <= maxRetries; attemptIdx++) {
+                try {
+                    const res = await attempt(req);
+                    if (res.status >= 200 && res.status < 300)
+                        return res;
+                    if (!RETRY_STATUSES.has(res.status) || attemptIdx === maxRetries) {
+                        let parsedBody = res.body;
+                        try {
+                            parsedBody = JSON.parse(res.body);
+                        }
+                        catch {
+                            /* keep text */
+                        }
+                        throw new HttpError(res.status, `HTTP ${res.status}`, parsedBody);
+                    }
+                }
+                catch (err) {
+                    if (err instanceof HttpError)
+                        throw err;
+                    lastErr = err;
+                    if (attemptIdx === maxRetries)
+                        break;
+                }
+                await sleep(retryDelayMs * 2 ** attemptIdx);
+            }
+            throw new HttpError(0, `Network failure after ${maxRetries + 1} attempts`, {
+                cause: String(lastErr),
+            });
+        },
+    };
+}

package/dist/src/core/jsonapi/client.js

@@ -0,0 +1,46 @@
+function joinUrl(base, prefix, path) {
+    const b = base.replace(/\/+$/, "");
+    const p = prefix.startsWith("/") ? prefix : `/${prefix}`;
+    const r = path.startsWith("/") ? path : `/${path}`;
+    return `${b}${p}${r}`;
+}
+const JSONAPI_HEADERS = {
+    Accept: "application/vnd.api+json",
+    "Content-Type": "application/vnd.api+json",
+};
+export function createJsonApiClient(opts) {
+    async function send(method, url, body, extraHeaders = {}) {
+        const reqBase = {
+            method,
+            url,
+            headers: { ...JSONAPI_HEADERS, ...extraHeaders },
+        };
+        const req = body !== undefined ? { ...reqBase, body } : reqBase;
+        const withAuth = await opts.auth.apply(req);
+        const res = await opts.http.send(withAuth);
+        if (res.status === 204 || res.body.length === 0)
+            return { ok: true };
+        return JSON.parse(res.body);
+    }
+    return {
+        async get(path, params) {
+            const qs = params ? `?${params.getQueryString()}` : "";
+            return send("GET", joinUrl(opts.baseUrl, opts.prefix, path) + qs);
+        },
+        async post(path, body) {
+            return send("POST", joinUrl(opts.baseUrl, opts.prefix, path), JSON.stringify(body));
+        },
+        async patch(path, body) {
+            return send("PATCH", joinUrl(opts.baseUrl, opts.prefix, path), JSON.stringify(body));
+        },
+        async delete(path) {
+            return send("DELETE", joinUrl(opts.baseUrl, opts.prefix, path));
+        },
+        async upload(path, filename, data) {
+            return send("POST", joinUrl(opts.baseUrl, opts.prefix, path), data, {
+                "Content-Type": "application/octet-stream",
+                "Content-Disposition": `file; filename="${filename}"`,
+            });
+        },
+    };
+}

package/dist/src/core/jsonapi/query.js

@@ -0,0 +1,18 @@
+export function buildQueryString(q) {
+    const params = new URLSearchParams();
+    for (const f of q.filter ?? []) {
+        params.append(`filter[${f.key}][value]`, f.value);
+        if (f.operator)
+            params.append(`filter[${f.key}][operator]`, f.operator);
+    }
+    if (q.sort)
+        params.append("sort", q.sort);
+    if (q.page?.limit !== undefined)
+        params.append("page[limit]", String(q.page.limit));
+    if (q.page?.offset !== undefined)
+        params.append("page[offset]", String(q.page.offset));
+    if (q.include && q.include.length > 0)
+        params.append("include", q.include.join(","));
+    const s = params.toString();
+    return s.length === 0 ? "" : `?${s}`;
+}

package/dist/src/core/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/schema/catalog.js

@@ -0,0 +1,29 @@
+import { HttpError } from "../../errors.js";
+function prettify(machine) {
+    const spaced = machine.replace(/_/g, " ");
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+export async function fetchCatalog(deps) {
+    const url = `${deps.baseUrl.replace(/\/+$/, "")}${deps.jsonapiPrefix.startsWith("/") ? deps.jsonapiPrefix : `/${deps.jsonapiPrefix}`}`;
+    const req = await deps.auth.apply({
+        method: "GET",
+        url,
+        headers: { Accept: "application/vnd.api+json" },
+    });
+    const res = await deps.http.send(req);
+    if (res.status < 200 || res.status >= 300) {
+        throw new HttpError(res.status, `cannot reach ${url}: HTTP ${res.status}`, res.body);
+    }
+    const body = JSON.parse(res.body);
+    const links = body.links ?? {};
+    const out = [];
+    for (const [key, link] of Object.entries(links)) {
+        if (!key.includes("--"))
+            continue;
+        // key.includes("--") guard above ensures two segments exist.
+        const [entity_type, bundle] = key.split("--", 2);
+        const label = link?.meta?.title ?? prettify(bundle);
+        out.push({ entity_type, bundle, label });
+    }
+    return out;
+}

package/dist/src/core/schema/jsonschema-source.js

@@ -0,0 +1,46 @@
+import { HttpError, ValidationError } from "../../errors.js";
+import { fetchHeuristic } from "./sources/heuristic.js";
+export async function fetchJsonSchema(deps) {
+    const { entity, bundle } = deps;
+    const target = { entity_type: entity, bundle };
+    const plugins = deps.plugins ?? [];
+    const ctx = { http: deps.http, auth: deps.auth, baseUrl: deps.baseUrl };
+    // Build heuristic base schema
+    let heuristicResult;
+    try {
+        heuristicResult = await fetchHeuristic({
+            http: deps.http,
+            auth: deps.auth,
+            baseUrl: deps.baseUrl,
+            jsonapiPrefix: deps.jsonapiPrefix,
+            entity,
+            bundle,
+        });
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            throw new ValidationError(`no such target '${entity}/${bundle}'. Run 'dropsh schema' to see available targets.`, { entity, bundle });
+        }
+        throw err;
+    }
+    let schema = heuristicResult.schema;
+    let source = heuristicResult.empty ? "heuristic-empty" : "heuristic";
+    // Run each plugin's extendSchema — a plugin may replace the schema entirely (e.g. schemata)
+    for (const plugin of plugins) {
+        const extended = await plugin.extendSchema(entity, bundle, schema, ctx);
+        if (extended !== schema) {
+            schema = extended;
+            source = plugin.id;
+        }
+    }
+    // Only warn when no plugin improved the schema
+    if (source === "heuristic" || source === "heuristic-empty") {
+        if (heuristicResult.empty) {
+            deps.warn(`warning: bundle '${entity}/${bundle}' has no instances and no schema plugin; returning envelope-only schema`);
+        }
+        else {
+            deps.warn(`warning: no schema plugin configured; returning heuristic schema (no required fields, no constraints)`);
+        }
+    }
+    return { schema, source, target };
+}

package/dist/src/core/schema/sources/heuristic.js

@@ -0,0 +1,100 @@
+import { HttpError } from "../../../errors.js";
+function inferType(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "array";
+    switch (typeof v) {
+        case "string":
+            return "string";
+        case "number":
+            return Number.isInteger(v) ? "integer" : "number";
+        case "boolean":
+            return "boolean";
+        default:
+            return "object";
+    }
+}
+function mergeTypes(types) {
+    const arr = [...types].filter((t) => t !== undefined);
+    if (arr.length === 0)
+        return {};
+    if (arr.length === 1)
+        return { type: arr[0] };
+    return { type: arr };
+}
+export async function fetchHeuristic(deps) {
+    const base = deps.baseUrl.replace(/\/+$/, "");
+    const prefix = deps.jsonapiPrefix.startsWith("/") ? deps.jsonapiPrefix : `/${deps.jsonapiPrefix}`;
+    const url = `${base}${prefix}/${deps.entity}/${deps.bundle}?page%5Blimit%5D=3`;
+    const req = await deps.auth.apply({
+        method: "GET",
+        url,
+        headers: { Accept: "application/vnd.api+json" },
+    });
+    const res = await deps.http.send(req);
+    if (res.status < 200 || res.status >= 300) {
+        throw new HttpError(res.status, `cannot reach ${url}: HTTP ${res.status}`, res.body);
+    }
+    const body = JSON.parse(res.body);
+    const records = body.data ?? [];
+    const resourceType = `${deps.entity}--${deps.bundle}`;
+    const attrTypes = new Map();
+    const relNames = new Set();
+    for (const r of records) {
+        for (const [k, v] of Object.entries(r.attributes ?? {})) {
+            if (!attrTypes.has(k))
+                attrTypes.set(k, new Set());
+            attrTypes.get(k)?.add(inferType(v));
+        }
+        for (const k of Object.keys(r.relationships ?? {}))
+            relNames.add(k);
+    }
+    const attrProps = {};
+    for (const [k, types] of attrTypes)
+        attrProps[k] = mergeTypes(types);
+    const relProps = {};
+    for (const k of relNames) {
+        relProps[k] = {
+            type: "object",
+            properties: {
+                data: {
+                    oneOf: [
+                        {
+                            type: "object",
+                            properties: { type: { type: "string" }, id: { type: "string", format: "uuid" } },
+                            required: ["type", "id"],
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: { type: { type: "string" }, id: { type: "string", format: "uuid" } },
+                                required: ["type", "id"],
+                            },
+                        },
+                        { type: "null" },
+                    ],
+                },
+            },
+        };
+    }
+    const schema = {
+        $schema: "https://json-schema.org/draft-07/schema",
+        type: "object",
+        properties: {
+            data: {
+                type: "object",
+                properties: {
+                    type: { const: resourceType },
+                    id: { type: "string", format: "uuid" },
+                    attributes: { type: "object", properties: attrProps, required: [] },
+                    relationships: { type: "object", properties: relProps, required: [] },
+                },
+                required: ["type"],
+            },
+        },
+        required: ["data"],
+    };
+    return { schema, empty: records.length === 0 };
+}

package/dist/src/core/schema/to-jsonschema.js

@@ -0,0 +1,51 @@
+const VALID_TYPES = new Set(["array", "boolean", "integer", "null", "number", "object", "string"]);
+function normalizeTypes(schema) {
+    if (Array.isArray(schema))
+        return schema.map(normalizeTypes);
+    if (typeof schema !== "object" || schema === null)
+        return schema;
+    const out = {};
+    for (const [k, v] of Object.entries(schema)) {
+        if (k === "type") {
+            if (typeof v === "string") {
+                if (VALID_TYPES.has(v))
+                    out[k] = v;
+                // else: drop Drupal-specific non-standard type string
+            }
+            else if (Array.isArray(v)) {
+                const valid = v.filter((t) => typeof t === "string" && VALID_TYPES.has(t));
+                if (valid.length > 0)
+                    out[k] = valid.length === 1 ? valid[0] : valid;
+                // else: drop all-invalid type array
+            }
+            else {
+                out[k] = normalizeTypes(v);
+            }
+        }
+        else {
+            out[k] = normalizeTypes(v);
+        }
+    }
+    return out;
+}
+export function toOperationVariant(schema, op) {
+    // biome-ignore lint/suspicious/noExplicitAny: deep JSON structure from external schemata source
+    const cloned = JSON.parse(JSON.stringify(normalizeTypes(schema)));
+    const data = cloned?.properties?.data;
+    if (data && typeof data === "object") {
+        if (op === "create") {
+            // id is server-assigned on create; strip it from required even if schemata includes it
+            if (Array.isArray(data.required)) {
+                data.required = data.required.filter((r) => r !== "id");
+            }
+        }
+        else {
+            data.required = ["type", "id"];
+            if (data.properties?.attributes)
+                data.properties.attributes.required = [];
+            if (data.properties?.relationships)
+                data.properties.relationships.required = [];
+        }
+    }
+    return cloned;
+}

package/dist/src/core/schema/validate.js

@@ -0,0 +1,32 @@
+import Ajv from "ajv";
+import draft6MetaSchema from "ajv/dist/refs/json-schema-draft-06.json" with { type: "json" };
+import draft7MetaSchema from "ajv/dist/refs/json-schema-draft-07.json" with { type: "json" };
+import { ValidationError } from "../../errors.js";
+export function validatePayload(schema, payload, target) {
+    const ajv = new Ajv({ allErrors: true, strict: false, validateSchema: false, logger: false });
+    // Schemata (Drupal module) may emit Draft-04 schemas that use `id` instead of `$id`.
+    // AJV v8 hard-throws on `id`; removing the keyword makes AJV silently ignore it.
+    ajv.removeKeyword("id");
+    if (!ajv.getSchema("http://json-schema.org/draft-06/schema#")) {
+        ajv.addMetaSchema(draft6MetaSchema);
+    }
+    if (!ajv.getSchema("http://json-schema.org/draft-07/schema")) {
+        ajv.addMetaSchema(draft7MetaSchema);
+    }
+    // Register the https URI variant so $schema annotations using it resolve correctly.
+    if (!ajv.getSchema("https://json-schema.org/draft-07/schema")) {
+        ajv.addMetaSchema({ ...draft7MetaSchema, $id: "https://json-schema.org/draft-07/schema" });
+    }
+    let validate;
+    try {
+        validate = ajv.compile(schema);
+    }
+    catch (err) {
+        throw new ValidationError(`schema for ${target} cannot be compiled: ${err.message}`, { cause: String(err) });
+    }
+    const ok = validate(payload);
+    if (!ok) {
+        const errors = (validate.errors ?? []);
+        throw new ValidationError(`payload does not match schema for ${target}`, { errors });
+    }
+}

package/dist/src/errors.js

@@ -0,0 +1,49 @@
+export class CliError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = "CliError";
+        this.code = code;
+        this.details = details;
+    }
+}
+export class ConfigError extends CliError {
+    constructor(message, details = {}) {
+        super("E_CONFIG", message, details);
+        this.name = "ConfigError";
+    }
+}
+export class AuthError extends CliError {
+    constructor(message, details = {}) {
+        super("E_AUTH", message, details);
+        this.name = "AuthError";
+    }
+}
+export class ValidationError extends CliError {
+    constructor(message, details = {}) {
+        super("E_VALIDATION", message, details);
+        this.name = "ValidationError";
+    }
+}
+export class HttpError extends CliError {
+    status;
+    body;
+    constructor(status, message, body = null) {
+        super("E_HTTP", message, { status, body });
+        this.name = "HttpError";
+        this.status = status;
+        this.body = body;
+    }
+}
+export function exitCodeFor(err) {
+    if (err instanceof ConfigError)
+        return 2;
+    if (err instanceof AuthError)
+        return 3;
+    if (err instanceof ValidationError)
+        return 4;
+    if (err instanceof HttpError)
+        return 5;
+    return 1;
+}