runline 0.1.0

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

@@ -0,0 +1,131 @@
+async function apiRequest(appId, apiKey, method, path, body, qs) {
+    const url = new URL(`https://api.adalo.com/v0/apps/${appId}${path}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0) {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Adalo API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginate(appId, apiKey, collectionId, limit) {
+    const results = [];
+    let offset = 0;
+    const pageSize = 100;
+    while (true) {
+        const data = (await apiRequest(appId, apiKey, "GET", `/collections/${collectionId}`, undefined, {
+            limit: pageSize,
+            offset,
+        }));
+        const items = data.records ?? [];
+        results.push(...items);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (items.length < pageSize)
+            break;
+        offset += items.length;
+    }
+    return results;
+}
+function getConn(ctx) {
+    return {
+        appId: ctx.connection.config.appId,
+        apiKey: ctx.connection.config.apiKey,
+    };
+}
+export default function adalo(rl) {
+    rl.setName("adalo");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        appId: {
+            type: "string",
+            required: true,
+            description: "Adalo application ID",
+            env: "ADALO_APP_ID",
+        },
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Adalo API key",
+            env: "ADALO_API_KEY",
+        },
+    });
+    rl.registerAction("collection.create", {
+        description: "Create a row in a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+            fields: { type: "object", required: true, description: "Field values as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { collectionId, fields } = input;
+            const { appId, apiKey } = getConn(ctx);
+            return apiRequest(appId, apiKey, "POST", `/collections/${collectionId}`, fields);
+        },
+    });
+    rl.registerAction("collection.get", {
+        description: "Get a row from a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+        },
+        async execute(input, ctx) {
+            const { collectionId, rowId } = input;
+            const { appId, apiKey } = getConn(ctx);
+            return apiRequest(appId, apiKey, "GET", `/collections/${collectionId}/${rowId}`);
+        },
+    });
+    rl.registerAction("collection.list", {
+        description: "List rows from a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { collectionId, limit } = input;
+            const { appId, apiKey } = getConn(ctx);
+            return paginate(appId, apiKey, collectionId, limit);
+        },
+    });
+    rl.registerAction("collection.update", {
+        description: "Update a row in a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+            fields: { type: "object", required: true, description: "Field values to update" },
+        },
+        async execute(input, ctx) {
+            const { collectionId, rowId, fields } = input;
+            const { appId, apiKey } = getConn(ctx);
+            return apiRequest(appId, apiKey, "PUT", `/collections/${collectionId}/${rowId}`, fields);
+        },
+    });
+    rl.registerAction("collection.delete", {
+        description: "Delete a row from a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+        },
+        async execute(input, ctx) {
+            const { collectionId, rowId } = input;
+            const { appId, apiKey } = getConn(ctx);
+            return apiRequest(appId, apiKey, "DELETE", `/collections/${collectionId}/${rowId}`);
+        },
+    });
+}

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

@@ -0,0 +1,279 @@
+const BASE_URL = "https://api.affinity.co";
+async function apiRequest(apiKey, method, path, body, qs) {
+    const url = new URL(`${BASE_URL}${path}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${btoa(`:${apiKey}`)}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0) {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Affinity API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginateAll(apiKey, path, dataKey, limit) {
+    const results = [];
+    let pageToken;
+    while (true) {
+        const qs = { page_size: 500 };
+        if (pageToken)
+            qs.page_token = pageToken;
+        const data = (await apiRequest(apiKey, "GET", path, undefined, qs));
+        const items = data[dataKey] ?? [];
+        results.push(...items);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        pageToken = data.page_token;
+        if (!pageToken)
+            break;
+    }
+    return results;
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function affinity(rl) {
+    rl.setName("affinity");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Affinity API key",
+            env: "AFFINITY_API_KEY",
+        },
+    });
+    // ── List ────────────────────────────────────────────
+    rl.registerAction("list.get", {
+        description: "Get a specific list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+        },
+        async execute(input, ctx) {
+            const { listId } = input;
+            return apiRequest(getKey(ctx), "GET", `/lists/${listId}`);
+        },
+    });
+    rl.registerAction("list.list", {
+        description: "List all lists",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { limit } = input ?? {};
+            const data = (await apiRequest(getKey(ctx), "GET", "/lists"));
+            if (limit)
+                return data.slice(0, limit);
+            return data;
+        },
+    });
+    // ── List Entry ──────────────────────────────────────
+    rl.registerAction("listEntry.create", {
+        description: "Create a new list entry",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            entityId: { type: "number", required: true, description: "Entity ID to add" },
+        },
+        async execute(input, ctx) {
+            const { listId, entityId, ...rest } = input;
+            return apiRequest(getKey(ctx), "POST", `/lists/${listId}/list-entries`, {
+                entity_id: entityId,
+                ...rest,
+            });
+        },
+    });
+    rl.registerAction("listEntry.get", {
+        description: "Get a specific list entry",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            listEntryId: { type: "string", required: true, description: "List Entry ID" },
+        },
+        async execute(input, ctx) {
+            const { listId, listEntryId } = input;
+            return apiRequest(getKey(ctx), "GET", `/lists/${listId}/list-entries/${listEntryId}`);
+        },
+    });
+    rl.registerAction("listEntry.list", {
+        description: "List all entries in a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { listId, limit } = input;
+            return paginateAll(getKey(ctx), `/lists/${listId}/list-entries`, "list_entries", limit);
+        },
+    });
+    rl.registerAction("listEntry.delete", {
+        description: "Delete a list entry",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            listEntryId: { type: "string", required: true, description: "List Entry ID" },
+        },
+        async execute(input, ctx) {
+            const { listId, listEntryId } = input;
+            return apiRequest(getKey(ctx), "DELETE", `/lists/${listId}/list-entries/${listEntryId}`);
+        },
+    });
+    // ── Person ──────────────────────────────────────────
+    rl.registerAction("person.create", {
+        description: "Create a new person",
+        inputSchema: {
+            firstName: { type: "string", required: true, description: "First name" },
+            lastName: { type: "string", required: true, description: "Last name" },
+            emails: { type: "array", required: true, description: "Array of email addresses" },
+            organizationIds: { type: "array", required: false, description: "Array of organization IDs" },
+        },
+        async execute(input, ctx) {
+            const { firstName, lastName, emails, organizationIds } = input;
+            const body = {
+                first_name: firstName,
+                last_name: lastName,
+                emails,
+            };
+            if (organizationIds)
+                body.organization_ids = organizationIds;
+            return apiRequest(getKey(ctx), "POST", "/persons", body);
+        },
+    });
+    rl.registerAction("person.get", {
+        description: "Get a specific person",
+        inputSchema: {
+            personId: { type: "string", required: true, description: "Person ID" },
+        },
+        async execute(input, ctx) {
+            const { personId } = input;
+            return apiRequest(getKey(ctx), "GET", `/persons/${personId}`);
+        },
+    });
+    rl.registerAction("person.list", {
+        description: "Search/list persons",
+        inputSchema: {
+            term: { type: "string", required: false, description: "Search term" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { term, limit } = input ?? {};
+            const qs = {};
+            if (term)
+                qs.term = term;
+            return paginateAll(getKey(ctx), "/persons", "persons", limit);
+        },
+    });
+    rl.registerAction("person.update", {
+        description: "Update a person",
+        inputSchema: {
+            personId: { type: "string", required: true, description: "Person ID" },
+            emails: { type: "array", required: true, description: "Array of email addresses" },
+            firstName: { type: "string", required: false, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            organizationIds: { type: "array", required: false, description: "Array of organization IDs" },
+        },
+        async execute(input, ctx) {
+            const { personId, firstName, lastName, emails, organizationIds } = input;
+            const body = { emails };
+            if (firstName)
+                body.first_name = firstName;
+            if (lastName)
+                body.last_name = lastName;
+            if (organizationIds)
+                body.organization_ids = organizationIds;
+            return apiRequest(getKey(ctx), "PUT", `/persons/${personId}`, body);
+        },
+    });
+    rl.registerAction("person.delete", {
+        description: "Delete a person",
+        inputSchema: {
+            personId: { type: "string", required: true, description: "Person ID" },
+        },
+        async execute(input, ctx) {
+            const { personId } = input;
+            return apiRequest(getKey(ctx), "DELETE", `/persons/${personId}`);
+        },
+    });
+    // ── Organization ────────────────────────────────────
+    rl.registerAction("organization.create", {
+        description: "Create a new organization",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Organization name" },
+            domain: { type: "string", required: true, description: "Organization domain" },
+            personIds: { type: "array", required: false, description: "Array of person IDs" },
+        },
+        async execute(input, ctx) {
+            const { name, domain, personIds } = input;
+            const body = { name, domain };
+            if (personIds)
+                body.person_ids = personIds;
+            return apiRequest(getKey(ctx), "POST", "/organizations", body);
+        },
+    });
+    rl.registerAction("organization.get", {
+        description: "Get a specific organization",
+        inputSchema: {
+            organizationId: { type: "string", required: true, description: "Organization ID" },
+        },
+        async execute(input, ctx) {
+            const { organizationId } = input;
+            return apiRequest(getKey(ctx), "GET", `/organizations/${organizationId}`);
+        },
+    });
+    rl.registerAction("organization.list", {
+        description: "Search/list organizations",
+        inputSchema: {
+            term: { type: "string", required: false, description: "Search term" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { term, limit } = input ?? {};
+            const qs = {};
+            if (term)
+                qs.term = term;
+            return paginateAll(getKey(ctx), "/organizations", "organizations", limit);
+        },
+    });
+    rl.registerAction("organization.update", {
+        description: "Update an organization",
+        inputSchema: {
+            organizationId: { type: "string", required: true, description: "Organization ID" },
+            name: { type: "string", required: false, description: "Organization name" },
+            domain: { type: "string", required: false, description: "Organization domain" },
+            personIds: { type: "array", required: false, description: "Array of person IDs" },
+        },
+        async execute(input, ctx) {
+            const { organizationId, name, domain, personIds } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (domain)
+                body.domain = domain;
+            if (personIds)
+                body.person_ids = personIds;
+            return apiRequest(getKey(ctx), "PUT", `/organizations/${organizationId}`, body);
+        },
+    });
+    rl.registerAction("organization.delete", {
+        description: "Delete an organization",
+        inputSchema: {
+            organizationId: { type: "string", required: true, description: "Organization ID" },
+        },
+        async execute(input, ctx) {
+            const { organizationId } = input;
+            return apiRequest(getKey(ctx), "DELETE", `/organizations/${organizationId}`);
+        },
+    });
+}