runline 0.11.2 → 0.11.4

package/dist/plugins/linear/src/views.js

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { CUSTOM_VIEW_FIELDS, FEED_ITEM_FIELDS, INITIATIVE_FIELDS, ISSUE_LITE, LIST_INPUT_SCHEMA, PROJECT_FIELDS, bindGetAction, bindListAction, buildConnArgs, gql, key, mergeIssueScopeFilter, requireUnscoped, } from "./shared.js";
+import { bindGetAction, bindListAction, buildConnArgs, CUSTOM_VIEW_FIELDS, FEED_ITEM_FIELDS, gql, INITIATIVE_FIELDS, ISSUE_LITE, key, LIST_INPUT_SCHEMA, mergeIssueScopeFilter, PROJECT_FIELDS, requireUnscoped, } from "./shared.js";
 const ISSUE_FILTER_DESCRIPTION = "IssueFilter payload. Examples: label { labels: { id: { in: ['label-id'] } } }; project { project: { id: { eq: 'project-id' } } }; assignee { assignee: { id: { eq: 'user-id' } } }; state { state: { id: { eq: 'state-id' } } }; priority { priority: { eq: 1 } }; due window { dueDate: { gte: '2026-06-09', lte: '2026-06-16' } }; combine with and/or arrays.";
 export function registerViewActions(rl) {
     const listAction = bindListAction(rl);
@@ -11,7 +11,9 @@ export function registerViewActions(rl) {
                 viewId: t.String({ description: "The custom view ID or slug" }),
                 ...LIST_INPUT_SCHEMA,
                 ...(includeSubTeamsDescription
-                    ? { includeSubTeams: t.Optional(t.Boolean({ description: includeSubTeamsDescription })) }
+                    ? {
+                        includeSubTeams: t.Optional(t.Boolean({ description: includeSubTeamsDescription })),
+                    }
                     : {}),
             }),
             async execute(input, ctx) {
@@ -24,7 +26,8 @@ export function registerViewActions(rl) {
                 const { argsDecl, argsCall, vars } = buildConnArgs(scopedOpts, filterTypeName);
                 const declParts = ["$id: String!", argsDecl.slice(1, -1)];
                 const callParts = [argsCall.slice(1, -1)];
-                const includeSubTeamsSet = includeSubTeamsDescription !== undefined && opts.includeSubTeams !== undefined;
+                const includeSubTeamsSet = includeSubTeamsDescription !== undefined &&
+                    opts.includeSubTeams !== undefined;
                 if (includeSubTeamsSet) {
                     declParts.push("$includeSubTeams: Boolean");
                     callParts.push("includeSubTeams: $includeSubTeams");
@@ -47,16 +50,22 @@ export function registerViewActions(rl) {
             description: t.Optional(t.String({ description: "The description of the custom view" })),
             icon: t.Optional(t.String({ description: "The icon of the custom view" })),
             color: t.Optional(t.String({ description: "The color of the custom view icon (hex)" })),
-            shared: t.Optional(t.Boolean({ description: "false creates a personal view; true shares the view with the workspace or scoped container" })),
+            shared: t.Optional(t.Boolean({
+                description: "false creates a personal view; true shares the view with the workspace or scoped container",
+            })),
             filterData: t.Optional(t.Object({}, { description: ISSUE_FILTER_DESCRIPTION })),
             projectFilterData: t.Optional(t.Object({}, { description: "ProjectFilter for project views" })),
             initiativeFilterData: t.Optional(t.Object({}, { description: "InitiativeFilter for initiative views" })),
             feedItemFilterData: t.Optional(t.Object({}, { description: "FeedItemFilter for update/feed item views" })),
             teamId: t.Optional(t.String({ description: "Scope the view to a team" })),
             projectId: t.Optional(t.String({ description: "Scope the view to a project-specific view" })),
-            initiativeId: t.Optional(t.String({ description: "Scope the view to an initiative-specific view" })),
+            initiativeId: t.Optional(t.String({
+                description: "Scope the view to an initiative-specific view",
+            })),
             ownerId: t.Optional(t.String({ description: "Set the user that owns the view" })),
-            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            id: t.Optional(t.String({
+                description: "The identifier in UUID v4 format. If none is provided, the backend will generate one",
+            })),
         }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "view.create");
@@ -67,19 +76,25 @@ export function registerViewActions(rl) {
     rl.registerAction("view.update", {
         description: "Update a custom view. All fields optional; only provided fields are updated.",
         inputSchema: t.Object({
-            id: t.String({ description: "The identifier of the custom view to update" }),
+            id: t.String({
+                description: "The identifier of the custom view to update",
+            }),
             name: t.Optional(t.String({ description: "The name of the custom view" })),
             description: t.Optional(t.String({ description: "The description of the custom view" })),
             icon: t.Optional(t.String({ description: "The icon of the custom view" })),
             color: t.Optional(t.String({ description: "The color of the custom view icon (hex)" })),
-            shared: t.Optional(t.Boolean({ description: "false creates a personal view; true shares the view with the workspace or scoped container" })),
+            shared: t.Optional(t.Boolean({
+                description: "false creates a personal view; true shares the view with the workspace or scoped container",
+            })),
             filterData: t.Optional(t.Object({}, { description: ISSUE_FILTER_DESCRIPTION })),
             projectFilterData: t.Optional(t.Object({}, { description: "ProjectFilter for project views" })),
             initiativeFilterData: t.Optional(t.Object({}, { description: "InitiativeFilter for initiative views" })),
             feedItemFilterData: t.Optional(t.Object({}, { description: "FeedItemFilter for update/feed item views" })),
             teamId: t.Optional(t.String({ description: "Scope the view to a team" })),
             projectId: t.Optional(t.String({ description: "Scope the view to a project-specific view" })),
-            initiativeId: t.Optional(t.String({ description: "Scope the view to an initiative-specific view" })),
+            initiativeId: t.Optional(t.String({
+                description: "Scope the view to an initiative-specific view",
+            })),
             ownerId: t.Optional(t.String({ description: "Set the user that owns the view" })),
         }),
         async execute(input, ctx) {
@@ -91,7 +106,11 @@ export function registerViewActions(rl) {
     });
     rl.registerAction("view.delete", {
         description: "Delete a custom view.",
-        inputSchema: t.Object({ id: t.String({ description: "The identifier of the custom view to delete" }) }),
+        inputSchema: t.Object({
+            id: t.String({
+                description: "The identifier of the custom view to delete",
+            }),
+        }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "view.delete");
             const data = await gql(key(ctx), `mutation($id: String!) { customViewDelete(id: $id) { success } }`, { id: input.id });

package/dist/plugins/linear/src/webhooks.js

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { WEBHOOK_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
+import { bindGetAction, bindListAction, gql, key, requireUnscoped, WEBHOOK_FIELDS, } from "./shared.js";
 export function registerWebhookActions(rl) {
     const listAction = bindListAction(rl);
     const getAction = bindGetAction(rl);
@@ -8,14 +8,28 @@ export function registerWebhookActions(rl) {
     rl.registerAction("webhook.create", {
         description: "Create a webhook. resourceTypes example: ['Issue','Comment','Project'].",
         inputSchema: t.Object({
-            url: t.String({ description: "The URL that will be called on data changes" }),
-            resourceTypes: t.Array(t.String(), { description: "List of resources the webhook should subscribe to (e.g. ['Issue','Comment'])" }),
+            url: t.String({
+                description: "The URL that will be called on data changes",
+            }),
+            resourceTypes: t.Array(t.String(), {
+                description: "List of resources the webhook should subscribe to (e.g. ['Issue','Comment'])",
+            }),
             label: t.Optional(t.String({ description: "Label for the webhook" })),
-            teamId: t.Optional(t.String({ description: "The identifier or key of the team associated with the webhook. Omit and set allPublicTeams=true for workspace-wide" })),
-            allPublicTeams: t.Optional(t.Boolean({ description: "Whether this webhook is enabled for all public teams" })),
-            enabled: t.Optional(t.Boolean({ description: "Whether this webhook is enabled (default true)" })),
-            secret: t.Optional(t.String({ description: "A secret token used to sign the webhook payload" })),
-            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            teamId: t.Optional(t.String({
+                description: "The identifier or key of the team associated with the webhook. Omit and set allPublicTeams=true for workspace-wide",
+            })),
+            allPublicTeams: t.Optional(t.Boolean({
+                description: "Whether this webhook is enabled for all public teams",
+            })),
+            enabled: t.Optional(t.Boolean({
+                description: "Whether this webhook is enabled (default true)",
+            })),
+            secret: t.Optional(t.String({
+                description: "A secret token used to sign the webhook payload",
+            })),
+            id: t.Optional(t.String({
+                description: "The identifier in UUID v4 format. If none is provided, the backend will generate one",
+            })),
         }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "webhooks.*");
@@ -27,11 +41,17 @@ export function registerWebhookActions(rl) {
         description: "Update a webhook. teamId and allPublicTeams cannot be changed after creation.",
         inputSchema: t.Object({
             id: t.String({ description: "The identifier of the webhook to update" }),
-            url: t.Optional(t.String({ description: "The URL that will be called on data changes" })),
-            resourceTypes: t.Optional(t.Array(t.String(), { description: "List of resources the webhook should subscribe to" })),
+            url: t.Optional(t.String({
+                description: "The URL that will be called on data changes",
+            })),
+            resourceTypes: t.Optional(t.Array(t.String(), {
+                description: "List of resources the webhook should subscribe to",
+            })),
             label: t.Optional(t.String({ description: "Label for the webhook" })),
             enabled: t.Optional(t.Boolean({ description: "Whether this webhook is enabled" })),
-            secret: t.Optional(t.String({ description: "A secret token used to sign the webhook payload" })),
+            secret: t.Optional(t.String({
+                description: "A secret token used to sign the webhook payload",
+            })),
         }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "webhooks.*");
@@ -42,7 +62,9 @@ export function registerWebhookActions(rl) {
     });
     rl.registerAction("webhook.delete", {
         description: "Delete a webhook.",
-        inputSchema: t.Object({ id: t.String({ description: "The identifier of the webhook to delete" }) }),
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the webhook to delete" }),
+        }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "webhooks.*");
             const data = await gql(key(ctx), `mutation($id: String!) { webhookDelete(id: $id) { success } }`, { id: input.id });
@@ -51,7 +73,11 @@ export function registerWebhookActions(rl) {
     });
     rl.registerAction("webhook.rotateSecret", {
         description: "Rotate a webhook's signing secret. Returns the new secret.",
-        inputSchema: t.Object({ id: t.String({ description: "The identifier of the webhook to rotate the secret for" }) }),
+        inputSchema: t.Object({
+            id: t.String({
+                description: "The identifier of the webhook to rotate the secret for",
+            }),
+        }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "webhooks.*");
             const data = await gql(key(ctx), `mutation($id: String!) { webhookRotateSecret(id: $id) { success secret } }`, { id: input.id });

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

@@ -1,224 +1,38 @@
-const API_VERSION = "v59.0";
-function getConn(ctx) {
-    const c = ctx.connection.config;
-    return {
-        instanceUrl: c.instanceUrl.replace(/\/$/, ""),
-        accessToken: c.accessToken,
-    };
-}
-async function api(conn, method, endpoint, body, qs) {
-    const url = new URL(`${conn.instanceUrl}/services/data/${API_VERSION}${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 ${conn.accessToken}`,
-            "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.status === 204)
-        return { success: true };
-    if (!res.ok)
-        throw new Error(`Salesforce error ${res.status}: ${await res.text()}`);
-    return res.json();
-}
-const SOBJECTS = [
-    "Account",
-    "Contact",
-    "Lead",
-    "Opportunity",
-    "Case",
-    "Task",
-    "User",
-];
-const DEFAULT_FIELDS = {
-    Account: "Id,Name,Type",
-    Contact: "Id,FirstName,LastName,Email",
-    Lead: "Id,Company,FirstName,LastName,Email,Status",
-    Opportunity: "Id,AccountId,Amount,Probability,StageName",
-    Case: "Id,AccountId,ContactId,Priority,Status,Subject",
-    Task: "Id,Subject,Status,Priority",
-    User: "Id,Name,Email",
-};
-function registerSObject(rl, sObject, conn) {
-    const lower = sObject.toLowerCase();
-    rl.registerAction(`${lower}.create`, {
-        description: `Create a ${sObject}`,
-        inputSchema: {
-            data: {
-                type: "object",
-                required: true,
-                description: `${sObject} field values`,
-            },
-        },
-        async execute(input, ctx) {
-            return api(conn(ctx), "POST", `/sobjects/${sObject}`, input.data);
-        },
-    });
-    rl.registerAction(`${lower}.get`, {
-        description: `Get a ${sObject} by ID`,
-        inputSchema: { id: { type: "string", required: true } },
-        async execute(input, ctx) {
-            return api(conn(ctx), "GET", `/sobjects/${sObject}/${input.id}`);
-        },
-    });
-    rl.registerAction(`${lower}.update`, {
-        description: `Update a ${sObject}`,
-        inputSchema: {
-            id: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            await api(conn(ctx), "PATCH", `/sobjects/${sObject}/${p.id}`, p.data);
-            return { success: true, id: p.id };
-        },
-    });
-    rl.registerAction(`${lower}.delete`, {
-        description: `Delete a ${sObject}`,
-        inputSchema: { id: { type: "string", required: true } },
-        async execute(input, ctx) {
-            await api(conn(ctx), "DELETE", `/sobjects/${sObject}/${input.id}`);
-            return { success: true };
-        },
-    });
-    rl.registerAction(`${lower}.query`, {
-        description: `Query ${sObject}s with SOQL`,
-        inputSchema: {
-            fields: {
-                type: "string",
-                required: false,
-                description: `Comma-separated (default: ${DEFAULT_FIELDS[sObject] ?? "Id"})`,
-            },
-            where: {
-                type: "string",
-                required: false,
-                description: "SOQL WHERE clause",
-            },
-            limit: { type: "number", required: false },
-        },
-        async execute(input, ctx) {
-            const p = (input ?? {});
-            const fields = p.fields || DEFAULT_FIELDS[sObject] || "Id";
-            let q = `SELECT ${fields} FROM ${sObject}`;
-            if (p.where)
-                q += ` WHERE ${p.where}`;
-            if (p.limit)
-                q += ` LIMIT ${p.limit}`;
-            const data = (await api(conn(ctx), "GET", "/query", undefined, {
-                q,
-            }));
-            return data.records;
-        },
-    });
-    rl.registerAction(`${lower}.upsert`, {
-        description: `Upsert a ${sObject} by external ID`,
-        inputSchema: {
-            externalIdField: { type: "string", required: true },
-            externalIdValue: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            return api(conn(ctx), "PATCH", `/sobjects/${sObject}/${p.externalIdField}/${p.externalIdValue}`, p.data);
-        },
-    });
-}
+import * as t from "typebox";
+import { registerMetadataActions } from "./metadata.js";
+import { registerQueryActions } from "./query.js";
+import { registerGenericSObjectActions, registerStandardSObjectActions, } from "./sobjects.js";
 export default function salesforce(rl) {
     rl.setName("salesforce");
-    rl.setVersion("0.1.0");
-    rl.setConnectionSchema({
-        instanceUrl: {
-            type: "string",
-            required: true,
-            description: "Salesforce instance URL (e.g. https://yourorg.my.salesforce.com)",
+    rl.setVersion("0.2.0");
+    rl.setConnectionSchema(t.Object({
+        instanceUrl: t.Optional(t.String({
+            description: "Salesforce API instance URL, e.g. https://your-domain.my.salesforce.com. Required for static accessToken auth; optional for client credentials when loginUrl is set.",
             env: "SALESFORCE_INSTANCE_URL",
-        },
-        accessToken: {
-            type: "string",
-            required: true,
-            description: "Salesforce OAuth2 access token",
+        })),
+        accessToken: t.Optional(t.String({
+            description: "Salesforce OAuth2 access token. Use for static-token auth.",
             env: "SALESFORCE_ACCESS_TOKEN",
-        },
-    });
-    for (const sObject of SOBJECTS) {
-        registerSObject(rl, sObject, getConn);
-    }
-    // ── Generic sObject ─────────────────────────────────
-    rl.registerAction("sobject.create", {
-        description: "Create any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            return api(getConn(ctx), "POST", `/sobjects/${p.sObject}`, p.data);
-        },
-    });
-    rl.registerAction("sobject.get", {
-        description: "Get any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            id: { type: "string", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            return api(getConn(ctx), "GET", `/sobjects/${p.sObject}/${p.id}`);
-        },
-    });
-    rl.registerAction("sobject.update", {
-        description: "Update any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            id: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            await api(getConn(ctx), "PATCH", `/sobjects/${p.sObject}/${p.id}`, p.data);
-            return { success: true };
-        },
-    });
-    rl.registerAction("sobject.delete", {
-        description: "Delete any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            id: { type: "string", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            await api(getConn(ctx), "DELETE", `/sobjects/${p.sObject}/${p.id}`);
-            return { success: true };
-        },
-    });
-    // ── SOQL Query ──────────────────────────────────────
-    rl.registerAction("soql.query", {
-        description: "Execute a raw SOQL query",
-        inputSchema: {
-            query: { type: "string", required: true, description: "Full SOQL query" },
-        },
-        async execute(input, ctx) {
-            const data = (await api(getConn(ctx), "GET", "/query", undefined, {
-                q: input.query,
-            }));
-            return data.records;
-        },
-    });
-    // ── Describe ────────────────────────────────────────
-    rl.registerAction("sobject.describe", {
-        description: "Describe an sObject's metadata/fields",
-        inputSchema: { sObject: { type: "string", required: true } },
-        async execute(input, ctx) {
-            return api(getConn(ctx), "GET", `/sobjects/${input.sObject}/describe`);
-        },
-    });
+        })),
+        loginUrl: t.Optional(t.String({
+            description: "Salesforce OAuth token host for client credentials, usually your My Domain URL such as https://your-domain.my.salesforce.com.",
+            env: "SALESFORCE_LOGIN_URL",
+        })),
+        clientId: t.Optional(t.String({
+            description: "Salesforce Connected App consumer key for OAuth client credentials flow.",
+            env: "SALESFORCE_CLIENT_ID",
+        })),
+        clientSecret: t.Optional(t.String({
+            description: "Salesforce Connected App consumer secret for OAuth client credentials flow.",
+            env: "SALESFORCE_CLIENT_SECRET",
+        })),
+        apiVersion: t.Optional(t.String({
+            description: "Salesforce REST API version (default v59.0). Accepts vXX.0 or XX.0.",
+            env: "SALESFORCE_API_VERSION",
+        })),
+    }));
+    registerMetadataActions(rl);
+    registerQueryActions(rl);
+    registerStandardSObjectActions(rl);
+    registerGenericSObjectActions(rl);
 }

package/dist/plugins/salesforce/src/metadata.js

@@ -0,0 +1,50 @@
+import * as t from "typebox";
+import { api, getSession, identity } from "./shared.js";
+export function registerMetadataActions(rl) {
+    rl.registerAction("connection.test", {
+        description: "Validate Salesforce auth and return safe connection metadata",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            const sessionPromise = getSession(ctx);
+            const session = await sessionPromise;
+            let limits;
+            let limitsError;
+            try {
+                limits = (await api(ctx, "GET", "/limits", undefined, undefined, sessionPromise));
+            }
+            catch (error) {
+                limitsError = error instanceof Error ? error.message : String(error);
+            }
+            return {
+                ok: true,
+                instanceUrl: session.instanceUrl,
+                tokenType: session.tokenType,
+                scope: session.scope,
+                id: session.id,
+                limits,
+                limitsError,
+            };
+        },
+    });
+    rl.registerAction("auth.identity", {
+        description: "Return the Salesforce OAuth identity for the current connection",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return identity(ctx);
+        },
+    });
+    rl.registerAction("limits.get", {
+        description: "Return Salesforce org REST API limits",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "GET", "/limits");
+        },
+    });
+    rl.registerAction("metadata.objects", {
+        description: "List available Salesforce sObjects and metadata summaries",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "GET", "/sobjects");
+        },
+    });
+}

package/dist/plugins/salesforce/src/query.js

@@ -0,0 +1,52 @@
+import * as t from "typebox";
+import { records } from "./queryResult.js";
+import { api, rest } from "./shared.js";
+const QueryInput = t.Object({
+    query: t.String({ description: "Full SOQL query" }),
+});
+async function queryPage(ctx, endpoint, query) {
+    return (await api(ctx, "GET", endpoint, undefined, {
+        q: query,
+    }));
+}
+export function registerQueryActions(rl) {
+    rl.registerAction("soql.query", {
+        description: "Execute a raw SOQL query and return the first page of records",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return records(await queryPage(ctx, "/query", input.query));
+        },
+    });
+    rl.registerAction("soql.queryPage", {
+        description: "Execute a raw SOQL query and return Salesforce pagination metadata",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return queryPage(ctx, "/query", input.query);
+        },
+    });
+    rl.registerAction("soql.queryAll", {
+        description: "Execute a raw SOQL query including deleted and archived records; returns the first page of records",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return records(await queryPage(ctx, "/queryAll", input.query));
+        },
+    });
+    rl.registerAction("soql.queryAllPage", {
+        description: "Execute a raw SOQL query including deleted and archived records and return Salesforce pagination metadata",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return queryPage(ctx, "/queryAll", input.query);
+        },
+    });
+    rl.registerAction("soql.nextPage", {
+        description: "Fetch the next page from a Salesforce nextRecordsUrl returned by soql.queryPage or soql.queryAllPage",
+        inputSchema: t.Object({
+            nextRecordsUrl: t.String({
+                description: "Salesforce nextRecordsUrl, e.g. /services/data/v59.0/query/01g...",
+            }),
+        }),
+        async execute(input, ctx) {
+            return rest(ctx, "GET", input.nextRecordsUrl);
+        },
+    });
+}

package/dist/plugins/salesforce/src/queryResult.js

@@ -0,0 +1,4 @@
+export function records(data) {
+    const value = data.records;
+    return Array.isArray(value) ? value : [];
+}