runline 0.32.0 → 0.34.0

package/dist/plugins/storyblok/src/index.js

@@ -1,47 +1,24 @@
-function getConn(ctx) {
-    const c = ctx.connection.config;
-    return {
-        contentToken: c.contentToken,
-        managementToken: c.managementToken,
-    };
-}
-async function contentApi(token, endpoint, qs) {
-    const url = new URL(`https://api.storyblok.com${endpoint}`);
-    url.searchParams.set("token", token);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const res = await fetch(url.toString());
-    if (!res.ok)
-        throw new Error(`Storyblok Content API error ${res.status}: ${await res.text()}`);
-    return res.json();
+import { credentialJson, pathSegment, pathSegments, } from "../../_shared/credentials.js";
+import { storyblokCredential } from "./credentials.js";
+function contentApi(ctx, path, query) {
+    return credentialJson(ctx, storyblokCredential, "storyblok", {
+        target: "content",
+        path,
+        query,
+    });
 }
-async function managementApi(token, method, endpoint, body, qs) {
-    const url = new URL(`https://mapi.storyblok.com${endpoint}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const init = {
+function managementApi(ctx, method, path, query) {
+    return credentialJson(ctx, storyblokCredential, "storyblok", {
+        target: "management",
+        path,
         method,
-        headers: { Authorization: token, "Content-Type": "application/json" },
-    };
-    if (body && Object.keys(body).length > 0)
-        init.body = JSON.stringify(body);
-    const res = await fetch(url.toString(), init);
-    if (!res.ok)
-        throw new Error(`Storyblok Management API error ${res.status}: ${await res.text()}`);
-    const text = await res.text();
-    return text ? JSON.parse(text) : {};
+        query,
+    });
 }
 export default function storyblok(rl) {
     rl.setName("storyblok");
     rl.setVersion("0.1.0");
+    rl.setCredential(storyblokCredential);
     rl.setConnectionSchema({
         contentToken: {
             type: "string",
@@ -68,10 +45,7 @@ export default function storyblok(rl) {
             },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
-            if (!conn.contentToken)
-                throw new Error("contentToken required for Content API");
-            const data = (await contentApi(conn.contentToken, `/v1/cdn/stories/${input.identifier}`));
+            const data = (await contentApi(ctx, `stories/${pathSegments(input.identifier)}`));
             return data.story;
         },
     });
@@ -87,16 +61,13 @@ export default function storyblok(rl) {
             },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
-            if (!conn.contentToken)
-                throw new Error("contentToken required for Content API");
             const p = (input ?? {});
             const qs = {};
             if (p.limit)
                 qs.per_page = p.limit;
             if (p.startsWith)
                 qs.starts_with = p.startsWith;
-            const data = (await contentApi(conn.contentToken, "/v1/cdn/stories", qs));
+            const data = (await contentApi(ctx, "stories", qs));
             return data.stories;
         },
     });
@@ -109,11 +80,8 @@ export default function storyblok(rl) {
             storyId: { type: "string", required: true },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
-            if (!conn.managementToken)
-                throw new Error("managementToken required for Management API");
             const p = input;
-            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories/${p.storyId}`));
+            const data = (await managementApi(ctx, "GET", `${pathSegment(p.spaceId)}/stories/${pathSegment(p.storyId)}`));
             return data.story;
         },
     });
@@ -125,14 +93,11 @@ export default function storyblok(rl) {
             limit: { type: "number", required: false },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
-            if (!conn.managementToken)
-                throw new Error("managementToken required for Management API");
             const p = (input ?? {});
             const qs = {};
             if (p.limit)
                 qs.per_page = p.limit;
-            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories`, undefined, qs));
+            const data = (await managementApi(ctx, "GET", `${pathSegment(p.spaceId)}/stories`, qs));
             return data.stories;
         },
     });
@@ -144,11 +109,8 @@ export default function storyblok(rl) {
             storyId: { type: "string", required: true },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
-            if (!conn.managementToken)
-                throw new Error("managementToken required for Management API");
             const p = input;
-            const data = (await managementApi(conn.managementToken, "DELETE", `/v1/spaces/${p.spaceId}/stories/${p.storyId}`));
+            const data = (await managementApi(ctx, "DELETE", `${pathSegment(p.spaceId)}/stories/${pathSegment(p.storyId)}`));
             return data.story;
         },
     });
@@ -162,16 +124,13 @@ export default function storyblok(rl) {
             language: { type: "string", required: false },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
-            if (!conn.managementToken)
-                throw new Error("managementToken required for Management API");
             const p = input;
             const qs = {};
             if (p.releaseId)
                 qs.release_id = p.releaseId;
             if (p.language)
                 qs.lang = p.language;
-            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories/${p.storyId}/publish`, undefined, qs));
+            const data = (await managementApi(ctx, "GET", `${pathSegment(p.spaceId)}/stories/${pathSegment(p.storyId)}/publish`, qs));
             return data.story;
         },
     });
@@ -183,11 +142,8 @@ export default function storyblok(rl) {
             storyId: { type: "string", required: true },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
-            if (!conn.managementToken)
-                throw new Error("managementToken required for Management API");
             const p = input;
-            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories/${p.storyId}/unpublish`));
+            const data = (await managementApi(ctx, "GET", `${pathSegment(p.spaceId)}/stories/${pathSegment(p.storyId)}/unpublish`));
             return data.story;
         },
     });

package/dist/plugins/strapi/src/credentials.js

@@ -0,0 +1,71 @@
+import { configChoice, grantSchema, httpsBase, staticCredential, } from "../../_shared/credentials.js";
+/** The Strapi major version the connection names, v4 when absent. */
+export function strapiVersion(config) {
+    return configChoice(config.apiVersion, ["v4", "v3"], "v4");
+}
+/** The content API beneath the instance: `api/` on v4, the root on v3. */
+function apiBase(config) {
+    const prefix = strapiVersion(config) === "v4" ? "api/" : "";
+    return {
+        prefix,
+        target: {
+            baseUrl: httpsBase(config.url, prefix),
+            methods: ["GET", "POST", "PUT", "DELETE"],
+        },
+    };
+}
+const apiToken = staticCredential({
+    id: "strapi",
+    auth: { kind: "bearer" },
+    local: { secret: "apiToken" },
+    targets: (config) => ({ api: apiBase(config).target }),
+});
+/**
+ * An API token as a bearer, or a user's email and password, logged in at
+ * the instance's /auth/local for a JWT the transport stores and signs
+ * with, logging in again when Strapi rejects it. `authMethod` picks one;
+ * without it, a connection holding a token uses the token and one naming
+ * an email logs in. The instance URL is public config and must be HTTPS.
+ */
+export const strapiCredential = (config) => {
+    const token = apiToken(config);
+    const method = configChoice(config.authMethod ??
+        (config.apiToken ? "apiToken" : config.email ? "password" : "apiToken"), ["apiToken", "password"], "apiToken");
+    const { prefix, target } = apiBase(config);
+    const type = {
+        id: "strapi",
+        methods: {
+            ...token.type.methods,
+            password: {
+                schema: grantSchema,
+                authentication: {
+                    kind: "oauth2",
+                    field: "grant",
+                    renewal: "password",
+                    definition: {
+                        id: "strapi.login",
+                        provider: "strapi",
+                        password: {
+                            url: httpsBase(config.url, `${prefix}auth/local`),
+                            clientAuthentication: "none",
+                            encoding: "json",
+                            grantType: null,
+                            fields: { username: "identifier" },
+                            response: { accessToken: "jwt" },
+                        },
+                    },
+                },
+                targets: { api: target },
+            },
+        },
+    };
+    if (method === "apiToken")
+        return { ...token, type };
+    return {
+        type,
+        method: "password",
+        ...(typeof config.email === "string" && typeof config.password === "string"
+            ? { resourceOwner: { username: config.email, password: config.password } }
+            : {}),
+    };
+};

package/dist/plugins/strapi/src/index.js

@@ -1,64 +1,29 @@
-function getConn(ctx) {
-    const c = ctx.connection.config;
-    return {
-        url: c.url.replace(/\/$/, ""),
-        apiVersion: c.apiVersion || "v4",
-        apiToken: c.apiToken,
-        email: c.email,
-        password: c.password,
-    };
+import { credentialJson, pathSegment } from "../../_shared/credentials.js";
+import { strapiCredential, strapiVersion } from "./credentials.js";
+/** Whether the connection speaks Strapi v4, whose answers wrap entries in `data`. */
+function isV4(ctx) {
+    return strapiVersion(ctx.connection.config) === "v4";
 }
-let cachedJwt;
-async function getJwt(conn) {
-    if (cachedJwt && cachedJwt.url === conn.url && Date.now() < cachedJwt.expiry)
-        return cachedJwt.token;
-    const authPath = conn.apiVersion === "v4" ? "/api/auth/local" : "/auth/local";
-    const res = await fetch(`${conn.url}${authPath}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ identifier: conn.email, password: conn.password }),
+/** A content API call; GET and DELETE carry no body. */
+function apiRequest(ctx, method, path, body, query) {
+    return credentialJson(ctx, strapiCredential, "strapi", {
+        target: "api",
+        path,
+        method,
+        query,
+        ...(body && method !== "GET" && method !== "DELETE" ? { json: body } : {}),
     });
-    if (!res.ok)
-        throw new Error(`Strapi auth error ${res.status}: ${await res.text()}`);
-    const data = (await res.json());
-    const jwt = data.jwt;
-    cachedJwt = { token: jwt, url: conn.url, expiry: Date.now() + 3600_000 };
-    return jwt;
 }
-async function apiRequest(conn, method, endpoint, body, qs) {
-    let token;
-    if (conn.apiToken) {
-        token = conn.apiToken;
-    }
-    else {
-        token = await getJwt(conn);
-    }
-    const prefix = conn.apiVersion === "v4" ? "/api" : "";
-    const url = new URL(`${conn.url}${prefix}${endpoint}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const init = {
-        method,
-        headers: {
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
-        },
-    };
-    if (body && Object.keys(body).length > 0)
-        init.body = JSON.stringify(body);
-    const res = await fetch(url.toString(), init);
-    if (!res.ok)
-        throw new Error(`Strapi error ${res.status}: ${await res.text()}`);
-    const text = await res.text();
-    return text ? JSON.parse(text) : {};
+/** An entry, or a content type's collection, as a path beneath the API. */
+function entryPath(contentType, entryId) {
+    return entryId === undefined
+        ? pathSegment(contentType)
+        : `${pathSegment(contentType)}/${pathSegment(entryId)}`;
 }
 export default function strapi(rl) {
     rl.setName("strapi");
     rl.setVersion("0.1.0");
+    rl.setCredential(strapiCredential);
     rl.setConnectionSchema({
         url: {
             type: "string",
@@ -72,6 +37,12 @@ export default function strapi(rl) {
             description: "v3 or v4 (default: v4)",
             env: "STRAPI_API_VERSION",
         },
+        authMethod: {
+            type: "string",
+            required: false,
+            description: "apiToken or password (inferred from which credential the connection holds)",
+            env: "STRAPI_AUTH_METHOD",
+        },
         apiToken: {
             type: "string",
             required: false,
@@ -103,12 +74,11 @@ export default function strapi(rl) {
             data: { type: "object", required: true, description: "Entry fields" },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
             const p = input;
-            const body = conn.apiVersion === "v4"
+            const body = isV4(ctx)
                 ? { data: p.data }
                 : p.data;
-            return apiRequest(conn, "POST", `/${p.contentType}`, body);
+            return apiRequest(ctx, "POST", entryPath(p.contentType), body);
         },
     });
     rl.registerAction("entry.get", {
@@ -119,10 +89,9 @@ export default function strapi(rl) {
             entryId: { type: "string", required: true },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
             const p = input;
-            const data = (await apiRequest(conn, "GET", `/${p.contentType}/${p.entryId}`));
-            return conn.apiVersion === "v4" ? data.data : data;
+            const data = (await apiRequest(ctx, "GET", entryPath(p.contentType, p.entryId)));
+            return isV4(ctx) ? data.data : data;
         },
     });
     rl.registerAction("entry.list", {
@@ -148,10 +117,9 @@ export default function strapi(rl) {
             },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
             const p = (input ?? {});
             const qs = {};
-            if (conn.apiVersion === "v4") {
+            if (isV4(ctx)) {
                 if (p.limit)
                     qs["pagination[pageSize]"] = p.limit;
                 if (p.sort)
@@ -160,7 +128,7 @@ export default function strapi(rl) {
                     qs.filters = p.filters;
                 if (p.publicationState)
                     qs.publicationState = p.publicationState;
-                const data = (await apiRequest(conn, "GET", `/${p.contentType}`, undefined, qs));
+                const data = (await apiRequest(ctx, "GET", entryPath(p.contentType), undefined, qs));
                 return data.data;
             }
             if (p.limit)
@@ -171,7 +139,7 @@ export default function strapi(rl) {
                 qs._where = p.filters;
             if (p.publicationState)
                 qs._publicationState = p.publicationState;
-            return apiRequest(conn, "GET", `/${p.contentType}`, undefined, qs);
+            return apiRequest(ctx, "GET", entryPath(p.contentType), undefined, qs);
         },
     });
     rl.registerAction("entry.update", {
@@ -183,13 +151,12 @@ export default function strapi(rl) {
             data: { type: "object", required: true, description: "Fields to update" },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
             const p = input;
-            const body = conn.apiVersion === "v4"
+            const body = isV4(ctx)
                 ? { data: p.data }
                 : p.data;
-            const result = (await apiRequest(conn, "PUT", `/${p.contentType}/${p.entryId}`, body));
-            return conn.apiVersion === "v4" ? result.data : result;
+            const result = (await apiRequest(ctx, "PUT", entryPath(p.contentType, p.entryId), body));
+            return isV4(ctx) ? result.data : result;
         },
     });
     rl.registerAction("entry.delete", {
@@ -200,9 +167,8 @@ export default function strapi(rl) {
             entryId: { type: "string", required: true },
         },
         async execute(input, ctx) {
-            const conn = getConn(ctx);
             const p = input;
-            return apiRequest(conn, "DELETE", `/${p.contentType}/${p.entryId}`);
+            return apiRequest(ctx, "DELETE", entryPath(p.contentType, p.entryId));
         },
     });
 }

package/dist/plugins/strava/src/credentials.js

@@ -0,0 +1,19 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/** An OAuth2 access token, sent as a bearer to Strava's one API origin. */
+export const stravaCredential = staticCredential({
+    id: "strava",
+    auth: { kind: "bearer" },
+    local: { secret: "accessToken" },
+    targets: {
+        api: {
+            baseUrl: "https://www.strava.com/api/v3/",
+            methods: ["GET", "POST", "PUT"],
+        },
+    },
+    probe: {
+        target: "api",
+        path: "athlete",
+        method: "GET",
+        acceptedStatuses: [200],
+    },
+});

package/dist/plugins/strava/src/index.js

@@ -1,34 +1,18 @@
-const BASE = "https://www.strava.com/api/v3";
-async function apiRequest(token, method, endpoint, body, qs) {
-    const url = new URL(`${BASE}${endpoint}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const init = {
+import { credentialJson, pathSegment } from "../../_shared/credentials.js";
+import { stravaCredential } from "./credentials.js";
+function apiRequest(ctx, method, path, body, qs) {
+    return credentialJson(ctx, stravaCredential, "strava", {
+        target: "api",
+        path,
         method,
-        headers: { Authorization: `Bearer ${token}` },
-    };
-    if (body && Object.keys(body).length > 0) {
-        const form = new URLSearchParams();
-        for (const [k, v] of Object.entries(body)) {
-            if (v !== undefined && v !== null)
-                form.set(k, String(v));
-        }
-        init.body = form;
-        init.headers["Content-Type"] =
-            "application/x-www-form-urlencoded";
-    }
-    const res = await fetch(url.toString(), init);
-    if (!res.ok)
-        throw new Error(`Strava error ${res.status}: ${await res.text()}`);
-    return res.json();
+        query: qs,
+        ...(body && Object.keys(body).length > 0 ? { form: body } : {}),
+    });
 }
 export default function strava(rl) {
     rl.setName("strava");
     rl.setVersion("0.1.0");
+    rl.setCredential(stravaCredential);
     rl.setConnectionSchema({
         accessToken: {
             type: "string",
@@ -37,7 +21,6 @@ export default function strava(rl) {
             env: "STRAVA_ACCESS_TOKEN",
         },
     });
-    const key = (ctx) => ctx.connection.config.accessToken;
     rl.registerAction("activity.create", {
         access: "write",
         description: "Create an activity",
@@ -83,7 +66,7 @@ export default function strava(rl) {
                 body.trainer = 1;
             if (p.commute)
                 body.commute = 1;
-            return apiRequest(key(ctx), "POST", "/activities", body);
+            return apiRequest(ctx, "POST", "activities", body);
         },
     });
     rl.registerAction("activity.get", {
@@ -91,7 +74,7 @@ export default function strava(rl) {
         description: "Get an activity by ID",
         inputSchema: { activityId: { type: "string", required: true } },
         async execute(input, ctx) {
-            return apiRequest(key(ctx), "GET", `/activities/${input.activityId}`);
+            return apiRequest(ctx, "GET", `activities/${pathSegment(input.activityId)}`);
         },
     });
     rl.registerAction("activity.list", {
@@ -102,7 +85,7 @@ export default function strava(rl) {
             const qs = {};
             if (input?.limit)
                 qs.per_page = input.limit;
-            return apiRequest(key(ctx), "GET", "/activities", undefined, qs);
+            return apiRequest(ctx, "GET", "activities", undefined, qs);
         },
     });
     rl.registerAction("activity.update", {
@@ -132,7 +115,7 @@ export default function strava(rl) {
                 body.commute = fields.commute;
             if (fields.gearId)
                 body.gear_id = fields.gearId;
-            return apiRequest(key(ctx), "PUT", `/activities/${activityId}`, body);
+            return apiRequest(ctx, "PUT", `activities/${pathSegment(activityId)}`, body);
         },
     });
     for (const sub of [
@@ -162,7 +145,7 @@ export default function strava(rl) {
             },
             async execute(input, ctx) {
                 const p = input;
-                const data = (await apiRequest(key(ctx), "GET", `/activities/${p.activityId}/${sub.path}`));
+                const data = (await apiRequest(ctx, "GET", `activities/${pathSegment(p.activityId)}/${sub.path}`));
                 if (p.limit)
                     return data.slice(0, p.limit);
                 return data;
@@ -182,7 +165,7 @@ export default function strava(rl) {
         },
         async execute(input, ctx) {
             const p = input;
-            return apiRequest(key(ctx), "GET", `/activities/${p.activityId}/streams`, undefined, { keys: p.keys, key_by_type: "true" });
+            return apiRequest(ctx, "GET", `activities/${pathSegment(p.activityId)}/streams`, undefined, { keys: p.keys, key_by_type: "true" });
         },
     });
 }

package/dist/plugins/stripe/src/credentials.js

@@ -0,0 +1,19 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/** A secret key, sent as a bearer to Stripe's v1 API base. */
+export const stripeCredential = staticCredential({
+    id: "stripe",
+    auth: { kind: "bearer" },
+    local: { secret: "secretKey" },
+    targets: {
+        api: {
+            baseUrl: "https://api.stripe.com/v1/",
+            methods: ["GET", "POST", "DELETE"],
+        },
+    },
+    probe: {
+        target: "api",
+        path: "balance",
+        method: "GET",
+        acceptedStatuses: [200],
+    },
+});