dropsh 0.5.8 → 0.6.0

package/dist/src/core/auth/types.d.ts

@@ -1,13 +1,26 @@
 import type { HttpClient, HttpRequest } from "../http.js";
+/**
+ * Outcome of a reactive credential renewal. On failure the renewal cause is
+ * carried back so the caller can surface *why* renewal failed instead of the
+ * bare, unexplained 401 that first triggered it.
+ */
+export type RenewOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    cause?: unknown;
+};
 export interface AuthAdapter {
     apply(req: HttpRequest): Promise<HttpRequest>;
     /**
      * Force a credential refresh after the server rejected the current token (401),
-     * then persist it. Returns true if renewal succeeded (caller retries the request
-     * once), false if it could not renew (caller surfaces the original 401).
-     * Providers that cannot renew (e.g. basic auth) omit this.
+     * then persist it. Resolves `{ ok: true }` when renewal succeeded (caller
+     * retries the request once) or `{ ok: false, cause }` when it could not renew,
+     * where `cause` is the error explaining the failure (the caller surfaces it in
+     * place of the original 401). Providers that cannot renew (e.g. basic auth)
+     * omit this method.
      */
-    renew?(): Promise<boolean>;
+    renew?(): Promise<RenewOutcome>;
 }
 /** Provider-specific opaque session payload persisted to the state dir. */
 export type AuthSession = Record<string, unknown>;

package/dist/src/core/jsonapi/client.d.ts

@@ -1,8 +1,9 @@
 import type { DrupalJsonApiParams } from "drupal-jsonapi-params";
 import type { AuthAdapter } from "../auth/types.js";
-import type { HttpClient } from "../http.js";
+import type { HttpClient, HttpRequest } from "../http.js";
 import { type Collection } from "./collection.js";
 import { type Resource } from "./resource.js";
+export type DropSHOperation = "read" | "search" | "create" | "update" | "delete" | "upload";
 /** Attributes/relationships payload accepted by create/update/upsert. */
 export interface ResourceWriteBody {
     attributes?: Record<string, unknown>;
@@ -35,5 +36,6 @@ export interface JsonApiOptions {
     prefix: string;
     http: HttpClient;
     auth: AuthAdapter;
+    alterRequest?: (req: HttpRequest, operation: DropSHOperation, entityType?: string, bundle?: string) => Promise<HttpRequest>;
 }
 export declare function createJsonApiClient(opts: JsonApiOptions): JsonApiClient;

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

@@ -12,27 +12,45 @@ const JSONAPI_HEADERS = {
     Accept: "application/vnd.api+json",
     "Content-Type": "application/vnd.api+json",
 };
+function targetFromPath(path) {
+    const [entityType, bundle] = path.split("/").filter(Boolean);
+    return {
+        ...(entityType !== undefined ? { entityType } : {}),
+        ...(bundle !== undefined ? { bundle } : {}),
+    };
+}
+function getOperation(path) {
+    const segments = path.split("/").filter(Boolean);
+    return segments.length === 0 || segments.length >= 3 ? "read" : "search";
+}
 export function createJsonApiClient(opts) {
-    async function send(method, url, body, extraHeaders = {}) {
+    async function send(method, path, operation, body, extraHeaders = {}, queryString = "") {
         const reqBase = {
             method,
-            url,
+            url: joinUrl(opts.baseUrl, opts.prefix, path) + queryString,
             headers: { ...JSONAPI_HEADERS, ...extraHeaders },
         };
         const req = body !== undefined ? { ...reqBase, body } : reqBase;
+        const authenticatedRequest = await opts.auth.apply(req);
+        const { entityType, bundle } = targetFromPath(path);
+        const alteredRequest = opts.alterRequest
+            ? await opts.alterRequest(authenticatedRequest, operation, entityType, bundle)
+            : authenticatedRequest;
         let res;
         try {
-            res = await opts.http.send(await opts.auth.apply(req));
+            res = await opts.http.send(alteredRequest);
         }
         catch (err) {
             // The server rejected the token (401). Ask the auth adapter to renew and,
-            // if it could, retry the request exactly once with a fresh token.
+            // if it could, retry the request exactly once with a fresh token. If it
+            // could not, surface the renewal cause (e.g. an unconfigured secret) so
+            // the caller sees *why* renewal failed, not just the original 401.
             if (!(err instanceof HttpError) || err.status !== 401 || !opts.auth.renew)
                 throw err;
-            const renewed = await opts.auth.renew();
-            if (!renewed)
-                throw err;
-            res = await opts.http.send(await opts.auth.apply(req));
+            const outcome = await opts.auth.renew();
+            if (!outcome.ok)
+                throw outcome.cause ?? err;
+            res = await opts.http.send(await opts.auth.apply(alteredRequest));
         }
         if (res.status === 204 || res.body.length === 0)
             return { ok: true };
@@ -41,19 +59,19 @@ export function createJsonApiClient(opts) {
     const client = {
         async get(path, params) {
             const qs = params ? `?${params.getQueryString()}` : "";
-            return send("GET", joinUrl(opts.baseUrl, opts.prefix, path) + qs);
+            return send("GET", path, getOperation(path), undefined, {}, qs);
         },
         async post(path, body) {
-            return send("POST", joinUrl(opts.baseUrl, opts.prefix, path), JSON.stringify(body));
+            return send("POST", path, "create", JSON.stringify(body));
         },
         async patch(path, body) {
-            return send("PATCH", joinUrl(opts.baseUrl, opts.prefix, path), JSON.stringify(body));
+            return send("PATCH", path, "update", JSON.stringify(body));
         },
         async delete(path) {
-            return send("DELETE", joinUrl(opts.baseUrl, opts.prefix, path));
+            return send("DELETE", path, "delete");
         },
         async upload(path, filename, data) {
-            return send("POST", joinUrl(opts.baseUrl, opts.prefix, path), data, {
+            return send("POST", path, "upload", data, {
                 "Content-Type": "application/octet-stream",
                 "Content-Disposition": `file; filename="${filename}"`,
             });

package/dist/src/core/plugin.d.ts

@@ -1,7 +1,8 @@
 import type { Command } from "commander";
 import type { AuthAdapter, AuthProvider } from "./auth/types.js";
 import type { AnyRenderer } from "./cli/render.js";
-import type { HttpClient } from "./http.js";
+import type { HttpClient, HttpRequest } from "./http.js";
+import type { DropSHOperation } from "./jsonapi/client.js";
 import type { Operation } from "./schema/to-jsonschema.js";
 export interface PluginContext {
     http: HttpClient;
@@ -21,6 +22,11 @@ export interface PluginContext {
     warn?: (message: string) => void;
 }
 export type SchemaOperation = Operation;
+export interface RequestContext extends PluginContext {
+    operation: DropSHOperation;
+    entityType?: string;
+    bundle?: string;
+}
 /**
  * Import-free descriptor naming a plugin package as a string. Same shape used
  * by the top-level `plugins[]` config; a plugin returns these in `dependencies`
@@ -50,6 +56,7 @@ export interface DropSHPlugin {
      */
     extendSchema?(entityType: string, bundle: string, baseSchema: unknown, ctx: PluginContext): Promise<unknown>;
     extendOperationSchema?(entityType: string, bundle: string, operation: SchemaOperation, operationSchema: unknown, ctx: PluginContext): Promise<unknown>;
+    alterRequest?(req: HttpRequest, ctx: RequestContext): Promise<HttpRequest>;
     registerCommands?(program: Command): void;
     renderers?: AnyRenderer[];
 }

package/dist/src/core/request-hooks.d.ts

@@ -0,0 +1,4 @@
+import type { HttpRequest } from "./http.js";
+import type { DropSHOperation } from "./jsonapi/client.js";
+import type { DropSHPlugin, PluginContext } from "./plugin.js";
+export declare function composeRequestHooks(plugins: DropSHPlugin[], ctx: PluginContext): (req: HttpRequest, operation: DropSHOperation, entityType?: string, bundle?: string) => Promise<HttpRequest>;

package/dist/src/core/request-hooks.js

@@ -0,0 +1,26 @@
+import { PluginError } from "../errors.js";
+export function composeRequestHooks(plugins, ctx) {
+    return async (req, operation, entityType, bundle) => {
+        const requestContext = {
+            ...ctx,
+            operation,
+            ...(entityType !== undefined ? { entityType } : {}),
+            ...(bundle !== undefined ? { bundle } : {}),
+        };
+        let current = req;
+        for (const plugin of plugins) {
+            if (!plugin.alterRequest)
+                continue;
+            try {
+                const next = await plugin.alterRequest(current, requestContext);
+                if (next === undefined)
+                    throw new Error("alterRequest must return an HttpRequest");
+                current = next;
+            }
+            catch (cause) {
+                throw new PluginError(plugin.id, "alterRequest", cause);
+            }
+        }
+        return current;
+    };
+}

package/dist/src/errors.d.ts

@@ -17,4 +17,7 @@ export declare class HttpError extends CliError {
     readonly body: unknown;
     constructor(status: number, message: string, body?: unknown);
 }
+export declare class PluginError extends CliError {
+    constructor(pluginId: string, hook: string, cause: unknown);
+}
 export declare function exitCodeFor(err: unknown): number;

package/dist/src/errors.js

@@ -36,6 +36,16 @@ export class HttpError extends CliError {
         this.body = body;
     }
 }
+export class PluginError extends CliError {
+    constructor(pluginId, hook, cause) {
+        super("E_PLUGIN", `plugin '${pluginId}' failed in ${hook}`, {
+            pluginId,
+            hook,
+            cause: String(cause),
+        });
+        this.name = "PluginError";
+    }
+}
 export function exitCodeFor(err) {
     if (err instanceof ConfigError)
         return 2;
@@ -45,5 +55,7 @@ export function exitCodeFor(err) {
         return 4;
     if (err instanceof HttpError)
         return 5;
+    if (err instanceof PluginError)
+        return 6;
     return 1;
 }

package/dist/src/index.js

@@ -17,6 +17,7 @@ import { createPrompt } from "./core/cli/prompt.js";
 import { loadConfig } from "./core/config.js";
 import { createHttpClient } from "./core/http.js";
 import { createJsonApiClient } from "./core/jsonapi/client.js";
+import { composeRequestHooks } from "./core/request-hooks.js";
 import { fetchJsonSchema } from "./core/schema/jsonschema-source.js";
 import { toOperationVariant } from "./core/schema/to-jsonschema.js";
 import { validatePayload } from "./core/schema/validate.js";
@@ -119,11 +120,18 @@ async function defaultContext(configPath, profile) {
         now: Date.now,
         ...(profile !== undefined ? { profile } : {}),
     });
+    const pluginContext = {
+        http,
+        auth,
+        baseUrl: cfg.site.base_url,
+        jsonapiPrefix: cfg.site.jsonapi_prefix,
+    };
     const client = createJsonApiClient({
         baseUrl: cfg.site.base_url,
         prefix: cfg.site.jsonapi_prefix,
         http,
         auth,
+        alterRequest: composeRequestHooks(cfg.plugins, pluginContext),
     });
     return {
         client,

package/dist/src/plugin-api.d.ts

@@ -7,12 +7,12 @@ export type { Config, SiteConfig } from "./core/config.js";
 export { loadConfig } from "./core/config.js";
 export type { HttpClient, HttpRequest } from "./core/http.js";
 export { createHttpClient } from "./core/http.js";
-export type { JsonApiClient, JsonApiOptions, ResourceWriteBody, } from "./core/jsonapi/client.js";
+export type { DropSHOperation, JsonApiClient, JsonApiOptions, ResourceWriteBody, } from "./core/jsonapi/client.js";
 export { createJsonApiClient } from "./core/jsonapi/client.js";
 export type { Collection, FilterOp } from "./core/jsonapi/collection.js";
 export type { JsonApiResourceObject, Resource, } from "./core/jsonapi/resource.js";
 export type { JsonApiDocument, JsonApiResource } from "./core/jsonapi/types.js";
-export type { DropSHPlugin, PluginContext, PluginDescriptor, SchemaOperation, } from "./core/plugin.js";
+export type { DropSHPlugin, PluginContext, PluginDescriptor, RequestContext, SchemaOperation, } from "./core/plugin.js";
 export { composePlugins } from "./core/plugin.js";
-export { AuthError, ConfigError, HttpError } from "./errors.js";
+export { AuthError, ConfigError, HttpError, PluginError } from "./errors.js";
 export type { CommandContext } from "./index.js";

package/dist/src/plugin-api.js

@@ -4,4 +4,4 @@ export { loadConfig } from "./core/config.js";
 export { createHttpClient } from "./core/http.js";
 export { createJsonApiClient } from "./core/jsonapi/client.js";
 export { composePlugins } from "./core/plugin.js";
-export { AuthError, ConfigError, HttpError } from "./errors.js";
+export { AuthError, ConfigError, HttpError, PluginError } from "./errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dropsh",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "Entity-agnostic helper CLI for Drupal 11 JSON:API, used by the dropsh Claude skill for editorial publishing workflows.",
   "type": "module",
   "bin": {