@zapier/zapier-sdk 0.77.1 → 0.77.2

package/dist/plugins/createConnection/index.js

@@ -1,71 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { setMethodMetadata } from "../eventEmission/method-metadata";
-import { appKeyResolver } from "../../resolvers";
-import openUrl from "../../utils/open-url";
-import { shouldOpenBrowser } from "../../utils/should-open-browser";
-import { CreateConnectionSchema, CreateConnectionItemSchema, } from "./schemas";
-export const createConnectionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "createConnection",
-    categories: ["connection"],
-    type: "create",
-    itemType: "Connection",
-    inputSchema: CreateConnectionSchema,
-    outputSchema: CreateConnectionItemSchema,
-    resolvers: { app: appKeyResolver },
-    formatter: {
-        format: (item) => ({
-            title: `Connection created: ${item.title || item.id}`,
-            id: item.id,
-            details: [
-                { text: `App: ${item.app}`, style: "normal" },
-                { text: `ID:  ${item.id}`, style: "accent" },
-            ],
-        }),
-    },
-    handler: async ({ sdk: inner, options, }) => {
-        const { data: start } = await inner.getConnectionStartUrl({
-            app: options.app,
-        });
-        // Tag this method's scope so eventEmission's onMethodEnd hook
-        // emits the MethodCalled event with `selected_api` set. The inner
-        // call sets metadata in its own scope, so we set it again here for
-        // createConnection's outer scope.
-        setMethodMetadata({ selectedApi: start.app });
-        // console.error (stderr) so JSON output on stdout (CLI --json flag)
-        // stays parseable, and so this works without bare `process` access in
-        // browser bundles — matching open-approval.ts. Always printed: a
-        // failed / skipped browser-open falls back to user copy-paste, so this
-        // is the load-bearing contract.
-        console.error(`\nOpen this URL to complete the connection:\n  ${start.url}\n`);
-        const shouldOpen = options.browser === "always" ||
-            (options.browser === "auto" && shouldOpenBrowser());
-        if (shouldOpen) {
-            try {
-                // Resolves once the OS handler is launched, not when the user
-                // finishes auth — that's waitForNewConnection's job.
-                await openUrl(start.url);
-            }
-            catch {
-                // openUrl can throw on unsupported platforms or when no handler is
-                // available. The URL is already printed to stderr, so the user can
-                // copy it.
-            }
-        }
-        const { data: fresh } = await inner.waitForNewConnection({
-            app: start.app,
-            // Server-stamped mint time: measured on the same clock as a
-            // connection's `date`, so the freshness check is immune to
-            // client/server clock skew.
-            startedAt: start.startedAt,
-            timeoutMs: options.timeoutMs,
-            pollIntervalMs: options.pollIntervalMs,
-        });
-        return {
-            data: CreateConnectionItemSchema.parse({
-                id: fresh.id,
-                app: start.app,
-                title: fresh.title ?? null,
-            }),
-        };
-    },
-}));

package/dist/plugins/createConnection/schemas.d.ts

@@ -1,21 +0,0 @@
-import { z } from "zod";
-export declare const CreateConnectionSchema: z.ZodObject<{
-    app: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    browser: z.ZodDefault<z.ZodEnum<{
-        never: "never";
-        auto: "auto";
-        always: "always";
-    }>>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-    pollIntervalMs: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type CreateConnectionOptions = z.infer<typeof CreateConnectionSchema>;
-export declare const CreateConnectionItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    app: z.ZodString;
-    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export type CreateConnectionItem = z.infer<typeof CreateConnectionItemSchema>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/createConnection/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/createConnection/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;iBA4BhC,CAAC;AAEJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE7E,eAAO,MAAM,0BAA0B;;;;iBAoBK,CAAC;AAE7C,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/plugins/createConnection/schemas.js

@@ -1,38 +0,0 @@
-import { z } from "zod";
-import { AppPropertySchema } from "../../types/properties";
-export const CreateConnectionSchema = z
-    .object({
-    app: AppPropertySchema,
-    browser: z
-        .enum(["auto", "always", "never"])
-        .default("auto")
-        .describe("When to auto-open the URL in a browser. `auto` (default) opens in local sessions and skips opening in CI / SSH / headless-Linux. `always` forces the open attempt. `never` skips it. The URL is always printed to stderr regardless — a failed or skipped open degrades gracefully to copy-paste."),
-    timeoutMs: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("How long to wait for the user to complete the connection flow before giving up. Default 5 minutes (300_000)."),
-    pollIntervalMs: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."),
-})
-    .describe("Create a new app connection, end-to-end. Mints the start URL via `get-connection-start-url`, prints it to stderr, opportunistically opens it in a browser when it looks safe to do so (skipping CI / SSH / headless-Linux by default — pass `--browser always` to force, `--browser never` to suppress), then polls via `wait-for-new-connection` until the user completes OAuth and the new connection appears. Returns the connection.\n\nThis is the right command for most callers. Reach for the lower-level building blocks when you want either of: (a) hand off the URL and *not* block on completion — call `get-connection-start-url` alone, no `wait-for-new-connection` needed, or (b) do something custom between minting the URL and waiting — call `get-connection-start-url`, do your work (email or DM the URL, render a QR code, etc.), then `wait-for-new-connection`.");
-export const CreateConnectionItemSchema = z
-    .object({
-    id: z
-        .string()
-        .describe("The new connection's ID. Public UUID when available, falling back to the numeric ID."),
-    app: z
-        .string()
-        .describe("Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."),
-    title: z
-        .string()
-        .nullable()
-        .optional()
-        .describe("Human-readable connection title set by the auth flow, when available."),
-})
-    .describe("The newly created connection.");

package/dist/plugins/deleteClientCredentials/index.d.ts

@@ -1,48 +0,0 @@
-import type { ApiClient } from "../../api";
-export declare const deleteClientCredentialsPlugin: (sdk: {
-    context: {
-        api: ApiClient;
-    };
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    listClientCredentials: (options?: ({
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        client_id: string;
-        name: string;
-        allowed_scopes: ("external" | "credentials")[];
-        created_at?: string | null | undefined;
-        updated_at?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listClientCredentials: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    deleteClientCredentials: (options?: {
-        clientId: string;
-    } | undefined) => Promise<{
-        success: boolean;
-    }>;
-} & {
-    context: {
-        meta: {
-            deleteClientCredentials: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type DeleteClientCredentialsPluginProvides = ReturnType<typeof deleteClientCredentialsPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/deleteClientCredentials/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/deleteClientCredentials/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAM3C,eAAO,MAAM,6BAA6B;aAEtB;QAAE,GAAG,EAAE,SAAS,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBrC,CAAC;AAEF,MAAM,MAAM,qCAAqC,GAAG,UAAU,CAC5D,OAAO,6BAA6B,CACrC,CAAC"}

package/dist/plugins/deleteClientCredentials/index.js

@@ -1,21 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { DeleteClientCredentialsSchema } from "./schemas";
-import { clientIdResolver } from "../../resolvers";
-export const deleteClientCredentialsPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "deleteClientCredentials",
-    categories: ["client-credentials"],
-    type: "delete",
-    itemType: "ClientCredentials",
-    inputSchema: DeleteClientCredentialsSchema,
-    resolvers: { clientId: clientIdResolver },
-    handler: async ({ sdk, options }) => {
-        const { api } = sdk.context;
-        await api.delete(`/api/v0/client-credentials/${options.clientId}`, undefined, {
-            authRequired: true,
-            requiredScopes: ["credentials"],
-            resource: { type: "client-credential", id: options.clientId },
-        });
-        return { success: true };
-    },
-}));

package/dist/plugins/deleteClientCredentials/schemas.d.ts

@@ -1,12 +0,0 @@
-import { z } from "zod";
-export declare const DeleteClientCredentialsSchema: z.ZodObject<{
-    clientId: z.ZodString;
-}, z.core.$strip>;
-export type DeleteClientCredentialsOptions = z.infer<typeof DeleteClientCredentialsSchema>;
-export interface DeleteClientCredentialsResult {
-    success: boolean;
-}
-export interface DeleteClientCredentialsSdkFunction {
-    deleteClientCredentials: (options: DeleteClientCredentialsOptions) => Promise<DeleteClientCredentialsResult>;
-}
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/deleteClientCredentials/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/deleteClientCredentials/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,eAAO,MAAM,6BAA6B;;iBAMW,CAAC;AAGtD,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,6BAA6B,CACrC,CAAC;AAGF,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,OAAO,CAAC;CAClB;AAGD,MAAM,WAAW,kCAAkC;IACjD,uBAAuB,EAAE,CACvB,OAAO,EAAE,8BAA8B,KACpC,OAAO,CAAC,6BAA6B,CAAC,CAAC;CAC7C"}

package/dist/plugins/deleteClientCredentials/schemas.js

@@ -1,8 +0,0 @@
-import { z } from "zod";
-export const DeleteClientCredentialsSchema = z
-    .object({
-    clientId: z
-        .string()
-        .describe("The client ID of the client credentials to delete"),
-})
-    .describe("Delete client credentials by client ID");