dropsh 0.0.1

package/dist/src/index.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { Command } from "commander";
+import { runCreate } from "./commands/create.js";
+import { runDelete } from "./commands/delete.js";
+import { runRead } from "./commands/read.js";
+import { runSchema } from "./commands/schema.js";
+import { runSearch } from "./commands/search.js";
+import { runUpdate } from "./commands/update.js";
+import { runUploadFile } from "./commands/upload-file.js";
+import { createFileStore } from "./core/cache/file-store.js";
+import { createOutput } from "./core/cli/output.js";
+import { loadConfig } from "./core/config.js";
+import { createHttpClient } from "./core/http.js";
+import { createJsonApiClient } from "./core/jsonapi/client.js";
+import { fetchJsonSchema } from "./core/schema/jsonschema-source.js";
+import { toOperationVariant } from "./core/schema/to-jsonschema.js";
+import { validatePayload } from "./core/schema/validate.js";
+import { ConfigError, exitCodeFor } from "./errors.js";
+function resolveConfigPath(override) {
+    return override ?? process.env.DROPSH_CONFIG ?? "dropsh.config.js";
+}
+async function defaultContext(configPath) {
+    const cfg = await loadConfig(configPath);
+    const http = createHttpClient({ timeoutMs: cfg.defaults.timeout_ms });
+    const authPlugin = cfg.plugins.find((p) => p.createAuthAdapter);
+    if (!authPlugin?.createAuthAdapter) {
+        throw new ConfigError("No auth plugin configured. Add basicAuthPlugin() or oauth2Plugin() to config.plugins.");
+    }
+    const auth = authPlugin.createAuthAdapter();
+    const client = createJsonApiClient({
+        baseUrl: cfg.site.base_url,
+        prefix: cfg.site.jsonapi_prefix,
+        http,
+        auth,
+    });
+    return {
+        client,
+        http,
+        auth,
+        baseUrl: cfg.site.base_url,
+        jsonapiPrefix: cfg.site.jsonapi_prefix,
+        cwd: process.cwd(),
+        plugins: cfg.plugins,
+    };
+}
+export function buildProgram(opts = {}) {
+    const program = new Command();
+    program
+        .name("dropsh")
+        .description("Entity-agnostic CLI for Drupal 11 JSON:API")
+        .version("0.0.0")
+        .option("--config <path>", "path to config file (overrides DROPSH_CONFIG)");
+    const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
+    const stderr = opts.stderr ?? ((s) => process.stderr.write(s));
+    const setExitCode = opts.setExitCode ??
+        ((c) => {
+            process.exitCode = c;
+        });
+    const contextFactory = opts.contextFactory ??
+        (() => defaultContext(resolveConfigPath(program.opts().config)));
+    const output = createOutput({ stdout, stderr });
+    async function run(fn) {
+        try {
+            const ctx = await contextFactory();
+            await fn(ctx);
+        }
+        catch (err) {
+            output.fail(err);
+            setExitCode(exitCodeFor(err));
+        }
+    }
+    async function loadOrFetchSchema(ctx, target, op) {
+        const store = createFileStore({
+            rootDir: `${ctx.cwd}/.dropsh/cache`,
+            warn: (m) => stderr(`${m}\n`),
+        });
+        const [entity, bundle] = target.split("/", 2);
+        const key = `schema/${entity}--${bundle}.${op}.json`;
+        const hit = await store.read(key);
+        if (hit !== undefined)
+            return hit;
+        const { schema: raw, source } = await fetchJsonSchema({
+            http: ctx.http,
+            auth: ctx.auth,
+            baseUrl: ctx.baseUrl,
+            jsonapiPrefix: ctx.jsonapiPrefix,
+            entity,
+            bundle,
+            warn: (m) => stderr(`${m}\n`),
+            plugins: ctx.plugins,
+        });
+        const transformed = toOperationVariant(raw, op);
+        const tagged = {
+            ...transformed,
+            "x-dropsh-source": source,
+            "x-dropsh-target": { entity_type: entity, bundle },
+            "x-dropsh-operation": op,
+        };
+        await store.write(key, tagged);
+        return tagged;
+    }
+    program
+        .command("read <target>")
+        .description("Read entity_type/bundle/uuid")
+        .action((target) => run((ctx) => runRead({ target }, { client: ctx.client, emit: output.emit })));
+    program
+        .command("search <entity_type>")
+        .description("Search entities with filters")
+        .option("--bundle <bundle>")
+        .option("--filter <kv...>", "filter in key:value or key:op:value form", [])
+        .option("--limit <n>", "max results", (v) => parseInt(v, 10), 50)
+        .action((entityType, o) => {
+        // biome-ignore lint/suspicious/noExplicitAny: optional bundle added conditionally
+        const args = { entityType, filters: o.filter, limit: o.limit };
+        if (o.bundle !== undefined)
+            args.bundle = o.bundle;
+        run((ctx) => runSearch(args, { client: ctx.client, emit: output.emit }));
+    });
+    program
+        .command("create <entity_type>")
+        .description("Create an entity of given type/bundle")
+        .requiredOption("--bundle <bundle>")
+        .requiredOption("--data <json>", "inline JSON or @path")
+        .option("--dry-run")
+        .option("--no-validate", "skip client-side schema validation")
+        .action((entityType, o) => {
+        const args = { entityType, bundle: o.bundle, dataArg: o.data };
+        if (o.dryRun !== undefined)
+            args.dryRun = o.dryRun;
+        if (o.validate === false)
+            args.noValidate = true;
+        run(async (ctx) => {
+            const deps = { client: ctx.client, emit: output.emit };
+            if (!args.noValidate) {
+                deps.validate = async (payload, target) => {
+                    const schema = await loadOrFetchSchema(ctx, target, "create");
+                    validatePayload(schema, payload, target);
+                };
+            }
+            await runCreate(args, deps);
+        });
+    });
+    program
+        .command("update <target>")
+        .description("Update an existing entity")
+        .requiredOption("--data <json>", "inline JSON or @path")
+        .option("--dry-run")
+        .option("--no-validate", "skip client-side schema validation")
+        .action((target, o) => {
+        const args = { target, dataArg: o.data };
+        if (o.dryRun !== undefined)
+            args.dryRun = o.dryRun;
+        if (o.validate === false)
+            args.noValidate = true;
+        run(async (ctx) => {
+            const deps = { client: ctx.client, emit: output.emit };
+            if (!args.noValidate) {
+                deps.validate = async (payload, t) => {
+                    const schema = await loadOrFetchSchema(ctx, t, "update");
+                    validatePayload(schema, payload, t);
+                };
+            }
+            await runUpdate(args, deps);
+        });
+    });
+    program
+        .command("delete <target>")
+        .description("Delete an entity")
+        .option("--dry-run")
+        .action((target, o) => {
+        // biome-ignore lint/suspicious/noExplicitAny: optional dryRun added conditionally
+        const args = { target };
+        if (o.dryRun !== undefined)
+            args.dryRun = o.dryRun;
+        run((ctx) => runDelete(args, { client: ctx.client, emit: output.emit }));
+    });
+    program
+        .command("upload-file")
+        .description("Upload a file to an entity's file/media field")
+        .requiredOption("--target <target>", "entity_type/bundle/uuid/field_name")
+        .requiredOption("--file <path>")
+        .option("--dry-run")
+        .action((o) => {
+        // biome-ignore lint/suspicious/noExplicitAny: optional dryRun added conditionally
+        const args = { target: o.target, file: o.file };
+        if (o.dryRun !== undefined)
+            args.dryRun = o.dryRun;
+        run((ctx) => runUploadFile(args, { client: ctx.client, emit: output.emit }));
+    });
+    program
+        .command("schema [target]")
+        .description("Catalog (no target) or JSON Schema for <entity>/<bundle>")
+        .option("--for <op>", "create|update", "create")
+        .option("--refresh", "bypass cache for this call")
+        .action((target, o) => {
+        const operation = o.for === "update" ? "update" : "create";
+        const schemaArgs = target !== undefined
+            ? { target, operation, refresh: Boolean(o.refresh) }
+            : { operation, refresh: Boolean(o.refresh) };
+        run((ctx) => runSchema(schemaArgs, {
+            http: ctx.http,
+            auth: ctx.auth,
+            baseUrl: ctx.baseUrl,
+            jsonapiPrefix: ctx.jsonapiPrefix,
+            cwd: ctx.cwd,
+            emit: output.emit,
+            warn: (m) => stderr(`${m}\n`),
+            plugins: ctx.plugins,
+        }));
+    });
+    if (opts.plugins) {
+        for (const plugin of opts.plugins) {
+            plugin.registerCommands?.(program);
+        }
+    }
+    program.exitOverride();
+    return program;
+}
+function earlyConfigArg(argv) {
+    const { values } = parseArgs({
+        args: argv.slice(2),
+        options: { config: { type: "string" } },
+        strict: false,
+    });
+    return typeof values.config === "string" ? values.config : undefined;
+}
+export async function main() {
+    const configPath = resolveConfigPath(earlyConfigArg(process.argv));
+    const cfg = await loadConfig(configPath).catch(() => null);
+    const plugins = cfg?.plugins ?? [];
+    const program = buildProgram({ plugins });
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (err) {
+        if (err.code === "commander.helpDisplayed")
+            return;
+        process.exitCode = process.exitCode ?? 1;
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}

package/dist/src/plugin-api.js

@@ -0,0 +1,4 @@
+export { basicAuthPlugin } from "./core/auth/basic.js";
+export { loadConfig } from "./core/config.js";
+export { createHttpClient } from "./core/http.js";
+export { AuthError, ConfigError, HttpError } from "./errors.js";

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "dropsh",
+  "version": "0.0.1",
+  "description": "Entity-agnostic helper CLI for Drupal 11 JSON:API, used by the dropsh Claude skill for editorial publishing workflows.",
+  "type": "module",
+  "bin": {
+    "dropsh": "./bin/dropsh"
+  },
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./plugin": "./dist/src/plugin-api.js"
+  },
+  "files": [
+    "bin",
+    "dist/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:plugins": "npm --prefix plugins/schemata run build && npm --prefix plugins/oauth2 run build",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "test:integration": "npm run build && vitest run -c vitest.config.integration.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/ tests/integrations/helpers/ tests/integrations/schema/ tests/integrations/*.ts",
+    "lint:fix": "biome check --write src/ tests/integrations/helpers/ tests/integrations/schema/ tests/integrations/*.ts",
+    "drupal:up": "bash tests/integrations/bin/drupal-up.sh",
+    "drupal:down": "bash tests/integrations/bin/drupal-down.sh",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "keywords": [
+    "drupal",
+    "drupal11",
+    "jsonapi",
+    "cli",
+    "claude",
+    "claude-skill",
+    "editorial"
+  ],
+  "author": "Christian Wiedemann <gitlab@keytec.de>",
+  "license": "(MIT OR GPL-2.0-or-later)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pen-drop/dropsh.git"
+  },
+  "dependencies": {
+    "ajv": "^8.18.0",
+    "commander": "^12.1.0",
+    "drupal-jsonapi-params": "^3.0.1",
+    "open": "^11.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.14",
+    "@types/node": "^20.14.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}