@zapier/zapier-sdk 0.26.0 → 0.27.0

package/dist/plugins/{findFirstAuthentication → findFirstConnection}/index.test.js

@@ -1,10 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { ZapierValidationError } from "../../types/errors";
-import { findFirstAuthenticationPlugin } from "./index";
+import { findFirstConnectionPlugin } from "./index";
 import { createSdk } from "../../sdk";
-import { ListAuthenticationsQuerySchema } from "../listAuthentications/schemas";
+import { ListConnectionsQuerySchema } from "../listConnections/schemas";
 import { eventEmissionPlugin } from "../eventEmission";
-const mockAuthentications = [
+const mockConnections = [
     {
         id: "123",
         title: "My Slack",
@@ -30,22 +30,22 @@ const mockAuthentications = [
         shared_with_all: false,
     },
 ];
-describe("findFirstAuthentication plugin", () => {
-    let mockListAuthentications;
+describe("findFirstConnection plugin", () => {
+    let mockListConnections;
     beforeEach(() => {
         vi.clearAllMocks();
-        mockListAuthentications = vi.fn().mockResolvedValue({
-            data: mockAuthentications,
+        mockListConnections = vi.fn().mockResolvedValue({
+            data: mockConnections,
         });
     });
     function createTestSdk() {
-        // Create a proper plugin chain: first add a mock listAuthentications plugin, then add findFirstAuthentication
-        const mockListAuthenticationsPlugin = () => ({
-            listAuthentications: mockListAuthentications,
+        // Create a proper plugin chain: first add a mock listConnections plugin, then add findFirstConnection
+        const mockListConnectionsPlugin = () => ({
+            listConnections: mockListConnections,
             context: {
                 meta: {
-                    listAuthentications: {
-                        inputSchema: ListAuthenticationsQuerySchema,
+                    listConnections: {
+                        inputSchema: ListConnectionsQuerySchema,
                     },
                 },
             },
@@ -58,35 +58,35 @@ describe("findFirstAuthentication plugin", () => {
             },
         }))
             .addPlugin(eventEmissionPlugin)
-            .addPlugin(mockListAuthenticationsPlugin)
-            .addPlugin(findFirstAuthenticationPlugin);
+            .addPlugin(mockListConnectionsPlugin)
+            .addPlugin(findFirstConnectionPlugin);
     }
     describe("schema validation", () => {
         it("should pass validation with empty options", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.findFirstAuthentication({});
+            const result = await sdk.findFirstConnection({});
             expect(result.data).toBeDefined();
         });
         it("should pass validation with undefined options", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.findFirstAuthentication();
+            const result = await sdk.findFirstConnection();
             expect(result.data).toBeDefined();
         });
         it("should throw validation error for invalid appKey type", async () => {
             const sdk = createTestSdk();
-            await expect(sdk.findFirstAuthentication({
+            await expect(sdk.findFirstConnection({
                 appKey: 123, // intentionally wrong type for testing
             })).rejects.toThrow(ZapierValidationError);
         });
         it("should throw validation error for invalid search type", async () => {
             const sdk = createTestSdk();
-            await expect(sdk.findFirstAuthentication({
+            await expect(sdk.findFirstConnection({
                 search: 123,
             })).rejects.toThrow(ZapierValidationError);
         });
         it("should throw validation error for invalid parameter types", async () => {
             const sdk = createTestSdk();
-            await expect(sdk.findFirstAuthentication({
+            await expect(sdk.findFirstConnection({
                 title: 123,
                 accountId: 456,
                 owner: true,
@@ -94,7 +94,7 @@ describe("findFirstAuthentication plugin", () => {
         });
         it("should pass validation with all valid fields", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.findFirstAuthentication({
+            const result = await sdk.findFirstConnection({
                 appKey: "slack",
                 search: "workspace",
                 title: "My Slack Workspace",
@@ -105,40 +105,40 @@ describe("findFirstAuthentication plugin", () => {
         });
     });
     describe("business logic", () => {
-        it("should return first authentication when found", async () => {
-            const mockAuth = mockAuthentications[0];
-            mockListAuthentications.mockResolvedValue({
-                data: [mockAuth],
+        it("should return first connection when found", async () => {
+            const mockConnection = mockConnections[0];
+            mockListConnections.mockResolvedValue({
+                data: [mockConnection],
             });
             const sdk = createTestSdk();
-            const result = await sdk.findFirstAuthentication({
+            const result = await sdk.findFirstConnection({
                 appKey: "slack",
             });
-            expect(result.data).toEqual(mockAuth);
+            expect(result.data).toEqual(mockConnection);
         });
-        it("should throw error when no authentications found", async () => {
-            mockListAuthentications.mockResolvedValue({
+        it("should throw error when no connections found", async () => {
+            mockListConnections.mockResolvedValue({
                 data: [],
             });
             const sdk = createTestSdk();
-            await expect(sdk.findFirstAuthentication({
+            await expect(sdk.findFirstConnection({
                 appKey: "nonexistent",
-            })).rejects.toThrow("No authentication found matching the specified criteria");
+            })).rejects.toThrow("No connection found matching the specified criteria");
         });
-        it("should return first authentication when multiple found", async () => {
-            const mockAuth = mockAuthentications[0];
-            mockListAuthentications.mockResolvedValue({
-                data: [mockAuth, mockAuthentications[1]],
+        it("should return first connection when multiple found", async () => {
+            const mockConnection = mockConnections[0];
+            mockListConnections.mockResolvedValue({
+                data: [mockConnection, mockConnections[1]],
             });
             const sdk = createTestSdk();
-            const result = await sdk.findFirstAuthentication({
+            const result = await sdk.findFirstConnection({
                 search: "Slack",
             });
-            expect(result.data).toEqual(mockAuth);
+            expect(result.data).toEqual(mockConnection);
         });
     });
     describe("options forwarding", () => {
-        it("should forward all options to listAuthentications", async () => {
+        it("should forward all options to listConnections", async () => {
             const sdk = createTestSdk();
             const options = {
                 appKey: "slack",
@@ -147,8 +147,8 @@ describe("findFirstAuthentication plugin", () => {
                 accountId: "acc_123",
                 owner: "me",
             };
-            await sdk.findFirstAuthentication(options);
-            expect(mockListAuthentications).toHaveBeenCalledWith(expect.objectContaining({
+            await sdk.findFirstConnection(options);
+            expect(mockListConnections).toHaveBeenCalledWith(expect.objectContaining({
                 ...options,
                 maxItems: 1,
             }));
@@ -157,10 +157,10 @@ describe("findFirstAuthentication plugin", () => {
     describe("limit enforcement", () => {
         it("should automatically set maxItems to 1", async () => {
             const sdk = createTestSdk();
-            await sdk.findFirstAuthentication({
+            await sdk.findFirstConnection({
                 appKey: "slack",
             });
-            expect(mockListAuthentications).toHaveBeenCalledWith(expect.objectContaining({
+            expect(mockListConnections).toHaveBeenCalledWith(expect.objectContaining({
                 appKey: "slack",
                 maxItems: 1,
             }));
@@ -170,8 +170,8 @@ describe("findFirstAuthentication plugin", () => {
         it("should provide context with meta information", () => {
             const sdk = createTestSdk();
             const context = sdk.getContext();
-            expect(context.meta.findFirstAuthentication).toBeDefined();
-            expect(context.meta.findFirstAuthentication.inputSchema).toBeDefined();
+            expect(context.meta.findFirstConnection).toBeDefined();
+            expect(context.meta.findFirstConnection.inputSchema).toBeDefined();
         });
     });
 });

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

@@ -0,0 +1,22 @@
+import type { z } from "zod";
+import type { ConnectionItem } from "../../types/domain";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
+export declare const FindFirstConnectionSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    appKey: z.ZodOptional<z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+    }>;
+    owner: z.ZodOptional<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    accountId: z.ZodOptional<z.ZodString>;
+    isExpired: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FindFirstConnectionOptions = z.infer<typeof FindFirstConnectionSchema>;
+export type FindFirstConnectionError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface FindFirstConnectionSdkFunction {
+    findFirstConnection: (options?: FindFirstConnectionOptions) => Promise<{
+        data: ConnectionItem | null;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/findFirstConnection/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAG5B,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAMwB,CAAC;AAG/D,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,yBAAyB,CACjC,CAAC;AAGF,MAAM,MAAM,wBAAwB,GAChC,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,8BAA8B;IAC7C,mBAAmB,EAAE,CACnB,OAAO,CAAC,EAAE,0BAA0B,KACjC,OAAO,CAAC;QAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CAC/C"}

package/dist/plugins/findFirstConnection/schemas.js

@@ -0,0 +1,8 @@
+import { ListConnectionsQuerySchema } from "../listConnections/schemas";
+export const FindFirstConnectionSchema = ListConnectionsQuerySchema.omit({
+    connectionIds: true,
+    pageSize: true,
+    maxItems: true,
+    cursor: true,
+    _telemetry: true,
+}).describe("Find the first connection matching the criteria");

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

@@ -0,0 +1,21 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ConnectionItem } from "../../types/domain";
+import { FindUniqueConnectionSchema, type FindUniqueConnectionOptions } from "./schemas";
+import type { ListConnectionsPluginProvides } from "../listConnections";
+import type { EventEmissionContext } from "../eventEmission";
+export interface FindUniqueConnectionPluginProvides {
+    findUniqueConnection: (options?: FindUniqueConnectionOptions) => Promise<{
+        data: ConnectionItem;
+    }>;
+    context: {
+        meta: {
+            findUniqueConnection: {
+                inputSchema: typeof FindUniqueConnectionSchema;
+            };
+        };
+    };
+}
+export declare const findUniqueConnectionPlugin: Plugin<GetSdkType<ListConnectionsPluginProvides>, // requires listConnections in SDK
+EventEmissionContext, // requires eventEmission in context
+FindUniqueConnectionPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/findUniqueConnection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EACL,0BAA0B,EAC1B,KAAK,2BAA2B,EACjC,MAAM,WAAW,CAAC;AAMnB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAG7D,MAAM,WAAW,kCAAkC;IACjD,oBAAoB,EAAE,CACpB,OAAO,CAAC,EAAE,2BAA2B,KAClC,OAAO,CAAC;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC,CAAC;IACvC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,oBAAoB,EAAE;gBACpB,WAAW,EAAE,OAAO,0BAA0B,CAAC;aAChD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAC7C,UAAU,CAAC,6BAA6B,CAAC,EAAE,kCAAkC;AAC7E,oBAAoB,EAAE,oCAAoC;AAC1D,kCAAkC,CAsDnC,CAAC"}

package/dist/plugins/findUniqueConnection/index.js

@@ -0,0 +1,40 @@
+import { FindUniqueConnectionSchema, } from "./schemas";
+import { ZapierResourceNotFoundError, ZapierValidationError, } from "../../types/errors";
+import { createFunction } from "../../utils/function-utils";
+import { ConnectionItemSchema } from "../../schemas/Connection";
+import { createTelemetryCallback } from "../../utils/telemetry-utils";
+export const findUniqueConnectionPlugin = ({ sdk, context }) => {
+    async function findUniqueConnection(options = {}) {
+        // Use listConnections with maxItems 2 to check for uniqueness
+        const connectionsResponse = await sdk.listConnections({
+            ...options,
+            maxItems: 2, // Get up to 2 to check for uniqueness
+            _telemetry: { isNested: true },
+        });
+        if (connectionsResponse.data.length === 0) {
+            throw new ZapierResourceNotFoundError("No connection found matching the specified criteria", { resourceType: "Connection" });
+        }
+        if (connectionsResponse.data.length > 1) {
+            throw new ZapierValidationError("Multiple connections found matching the specified criteria. Expected exactly one.");
+        }
+        return {
+            data: connectionsResponse.data[0],
+        };
+    }
+    const findUniqueConnectionDefinition = createFunction(findUniqueConnection, FindUniqueConnectionSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, findUniqueConnection.name));
+    return {
+        findUniqueConnection: findUniqueConnectionDefinition,
+        context: {
+            meta: {
+                findUniqueConnection: {
+                    categories: ["connection"],
+                    type: "item",
+                    itemType: "Connection",
+                    inputSchema: FindUniqueConnectionSchema,
+                    outputSchema: ConnectionItemSchema,
+                    deprecatedParameters: ["authenticationIds"],
+                },
+            },
+        },
+    };
+};

package/dist/plugins/findUniqueConnection/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/findUniqueConnection/index.test.ts"],"names":[],"mappings":""}

package/dist/plugins/{findUniqueAuthentication → findUniqueConnection}/index.test.js

@@ -1,10 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { ZapierValidationError, ZapierResourceNotFoundError, } from "../../types/errors";
-import { findUniqueAuthenticationPlugin } from "./index";
+import { findUniqueConnectionPlugin } from "./index";
 import { createSdk } from "../../sdk";
-import { ListAuthenticationsQuerySchema } from "../listAuthentications/schemas";
+import { ListConnectionsQuerySchema } from "../listConnections/schemas";
 import { eventEmissionPlugin } from "../eventEmission";
-const mockAuthentication = {
+const mockConnection = {
     id: "123",
     title: "My Slack",
     date: "2021-01-01",
@@ -16,8 +16,8 @@ const mockAuthentication = {
     is_private: false,
     shared_with_all: false,
 };
-const mockAuthentications = [
-    mockAuthentication,
+const mockConnections = [
+    mockConnection,
     {
         id: "456",
         title: "Slack Workspace 2",
@@ -31,22 +31,22 @@ const mockAuthentications = [
         shared_with_all: false,
     },
 ];
-describe("findUniqueAuthentication plugin", () => {
-    let mockListAuthentications;
+describe("findUniqueConnection plugin", () => {
+    let mockListConnections;
     beforeEach(() => {
         vi.clearAllMocks();
-        mockListAuthentications = vi.fn().mockResolvedValue({
-            data: [mockAuthentication],
+        mockListConnections = vi.fn().mockResolvedValue({
+            data: [mockConnection],
         });
     });
     function createTestSdk() {
-        // Create a proper plugin chain: first add a mock listAuthentications plugin, then add findUniqueAuthentication
-        const mockListAuthenticationsPlugin = () => ({
-            listAuthentications: mockListAuthentications,
+        // Create a proper plugin chain: first add a mock listConnections plugin, then add findUniqueConnection
+        const mockListConnectionsPlugin = () => ({
+            listConnections: mockListConnections,
             context: {
                 meta: {
-                    listAuthentications: {
-                        inputSchema: ListAuthenticationsQuerySchema,
+                    listConnections: {
+                        inputSchema: ListConnectionsQuerySchema,
                     },
                 },
             },
@@ -59,24 +59,24 @@ describe("findUniqueAuthentication plugin", () => {
             },
         }))
             .addPlugin(eventEmissionPlugin)
-            .addPlugin(mockListAuthenticationsPlugin)
-            .addPlugin(findUniqueAuthenticationPlugin);
+            .addPlugin(mockListConnectionsPlugin)
+            .addPlugin(findUniqueConnectionPlugin);
     }
     describe("schema validation", () => {
         it("should pass validation with empty options", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.findUniqueAuthentication({});
+            const result = await sdk.findUniqueConnection({});
             expect(result.data).toBeDefined();
         });
         it("should throw validation error for invalid appKey type", async () => {
             const sdk = createTestSdk();
-            await expect(sdk.findUniqueAuthentication({
+            await expect(sdk.findUniqueConnection({
                 appKey: 123,
             })).rejects.toThrow(ZapierValidationError);
         });
         it("should throw validation error for invalid parameter types", async () => {
             const sdk = createTestSdk();
-            await expect(sdk.findUniqueAuthentication({
+            await expect(sdk.findUniqueConnection({
                 search: 123,
                 title: 456,
                 accountId: 789,
@@ -85,7 +85,7 @@ describe("findUniqueAuthentication plugin", () => {
         });
         it("should pass validation with all valid fields", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.findUniqueAuthentication({
+            const result = await sdk.findUniqueConnection({
                 appKey: "slack",
                 search: "Workspace",
                 title: "My Slack",
@@ -96,43 +96,43 @@ describe("findUniqueAuthentication plugin", () => {
         });
     });
     describe("business logic", () => {
-        it("should return the first authentication when exactly one is found", async () => {
-            mockListAuthentications.mockResolvedValue({
-                data: [mockAuthentication],
+        it("should return the first connection when exactly one is found", async () => {
+            mockListConnections.mockResolvedValue({
+                data: [mockConnection],
             });
             const sdk = createTestSdk();
-            const result = await sdk.findUniqueAuthentication({
+            const result = await sdk.findUniqueConnection({
                 appKey: "slack",
             });
-            expect(result.data).toEqual(mockAuthentication);
+            expect(result.data).toEqual(mockConnection);
         });
-        it("should throw ZapierResourceNotFoundError when no authentications found", async () => {
-            mockListAuthentications.mockResolvedValue({
+        it("should throw ZapierResourceNotFoundError when no connections found", async () => {
+            mockListConnections.mockResolvedValue({
                 data: [],
             });
             const sdk = createTestSdk();
-            await expect(sdk.findUniqueAuthentication({
+            await expect(sdk.findUniqueConnection({
                 appKey: "nonexistent",
             })).rejects.toThrow(ZapierResourceNotFoundError);
-            await expect(sdk.findUniqueAuthentication({
+            await expect(sdk.findUniqueConnection({
                 appKey: "nonexistent",
-            })).rejects.toThrow("No authentication found matching the specified criteria");
+            })).rejects.toThrow("No connection found matching the specified criteria");
         });
-        it("should throw ZapierValidationError when multiple authentications found", async () => {
-            mockListAuthentications.mockResolvedValue({
-                data: mockAuthentications, // Two authentications
+        it("should throw ZapierValidationError when multiple connections found", async () => {
+            mockListConnections.mockResolvedValue({
+                data: mockConnections, // Two connections
             });
             const sdk = createTestSdk();
-            await expect(sdk.findUniqueAuthentication({
+            await expect(sdk.findUniqueConnection({
                 search: "Workspace",
             })).rejects.toThrow(ZapierValidationError);
-            await expect(sdk.findUniqueAuthentication({
+            await expect(sdk.findUniqueConnection({
                 search: "Workspace",
-            })).rejects.toThrow("Multiple authentications found matching the specified criteria. Expected exactly one.");
+            })).rejects.toThrow("Multiple connections found matching the specified criteria. Expected exactly one.");
         });
     });
     describe("options forwarding", () => {
-        it("should forward all options to listAuthentications with maxItems=2", async () => {
+        it("should forward all options to listConnections with maxItems=2", async () => {
             const sdk = createTestSdk();
             const options = {
                 appKey: "slack",
@@ -141,8 +141,8 @@ describe("findUniqueAuthentication plugin", () => {
                 accountId: "acc_123",
                 owner: "me",
             };
-            await sdk.findUniqueAuthentication(options);
-            expect(mockListAuthentications).toHaveBeenCalledWith(expect.objectContaining({
+            await sdk.findUniqueConnection(options);
+            expect(mockListConnections).toHaveBeenCalledWith(expect.objectContaining({
                 ...options,
                 maxItems: 2,
             }));
@@ -152,8 +152,8 @@ describe("findUniqueAuthentication plugin", () => {
         it("should provide context with meta information", () => {
             const sdk = createTestSdk();
             const context = sdk.getContext();
-            expect(context.meta.findUniqueAuthentication).toBeDefined();
-            expect(context.meta.findUniqueAuthentication.inputSchema).toBeDefined();
+            expect(context.meta.findUniqueConnection).toBeDefined();
+            expect(context.meta.findUniqueConnection.inputSchema).toBeDefined();
         });
     });
 });

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

@@ -0,0 +1,22 @@
+import type { z } from "zod";
+import type { ConnectionItem } from "../../types/domain";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierResourceNotFoundError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
+export declare const FindUniqueConnectionSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    appKey: z.ZodOptional<z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+    }>;
+    owner: z.ZodOptional<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    accountId: z.ZodOptional<z.ZodString>;
+    isExpired: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FindUniqueConnectionOptions = z.infer<typeof FindUniqueConnectionSchema>;
+export type FindUniqueConnectionError = ZapierAuthenticationError | ZapierApiError | ZapierResourceNotFoundError | ZapierValidationError | ZapierUnknownError;
+export interface FindUniqueConnectionSdkFunction {
+    findUniqueConnection: (options?: FindUniqueConnectionOptions) => Promise<{
+        data: ConnectionItem;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/findUniqueConnection/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,2BAA2B,EAC3B,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAG5B,eAAO,MAAM,0BAA0B;;;;;;;;;;iBAMsB,CAAC;AAG9D,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,0BAA0B,CAClC,CAAC;AAGF,MAAM,MAAM,yBAAyB,GACjC,yBAAyB,GACzB,cAAc,GACd,2BAA2B,GAC3B,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,+BAA+B;IAC9C,oBAAoB,EAAE,CACpB,OAAO,CAAC,EAAE,2BAA2B,KAClC,OAAO,CAAC;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC,CAAC;CACxC"}

package/dist/plugins/findUniqueConnection/schemas.js

@@ -0,0 +1,8 @@
+import { ListConnectionsQuerySchema } from "../listConnections/schemas";
+export const FindUniqueConnectionSchema = ListConnectionsQuerySchema.omit({
+    connectionIds: true,
+    pageSize: true,
+    maxItems: true,
+    cursor: true,
+    _telemetry: true,
+}).describe("Find a unique connection matching the criteria");

package/dist/plugins/getApp/index.js

@@ -7,13 +7,13 @@ import { createTelemetryCallback } from "../../utils/telemetry-utils";
 // GetApp plugin depends on listApps SDK function
 export const getAppPlugin = ({ sdk, context }) => {
     async function getApp(options) {
-        const appsIterator = sdk
+        const appsIterable = sdk
             .listApps({
             appKeys: [options.appKey],
             _telemetry: { isNested: true },
         })
             .items();
-        for await (const app of appsIterator) {
+        for await (const app of appsIterable) {
             return {
                 data: app,
             };

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

@@ -0,0 +1,22 @@
+import type { Plugin } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import type { EventEmissionContext } from "../eventEmission";
+import type { GetConnectionResponse } from "@zapier/zapier-sdk-core/v0/schemas/connections";
+import { GetConnectionParamSchema, type GetConnectionParam } from "./schemas";
+export interface GetConnectionPluginProvides {
+    getConnection: (options: GetConnectionParam) => Promise<GetConnectionResponse>;
+    context: {
+        meta: {
+            getConnection: {
+                inputSchema: typeof GetConnectionParamSchema;
+            };
+        };
+    };
+}
+export declare const getConnectionPlugin: Plugin<{}, // no SDK dependencies
+// no SDK dependencies
+{
+    api: ApiClient;
+} & EventEmissionContext, // requires api in context
+GetConnectionPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getConnection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAI3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAC5F,OAAO,EAAE,wBAAwB,EAAE,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE9E,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,CACb,OAAO,EAAE,kBAAkB,KACxB,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACpC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,aAAa,EAAE;gBACb,WAAW,EAAE,OAAO,wBAAwB,CAAC;aAC9C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,mBAAmB,EAAE,MAAM,CACtC,EAAE,EAAE,sBAAsB;AAC1B,AADI,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EAAE,0BAA0B;AACrE,2BAA2B,CA6C5B,CAAC"}

package/dist/plugins/getConnection/index.js

@@ -0,0 +1,35 @@
+import { createFunction } from "../../utils/function-utils";
+import { connectionIdGenericResolver } from "../../resolvers";
+import { ConnectionItemSchema } from "../../schemas/Connection";
+import { createTelemetryCallback } from "../../utils/telemetry-utils";
+import { GetConnectionParamSchema } from "./schemas";
+export const getConnectionPlugin = ({ context }) => {
+    async function getConnection(options) {
+        const { api } = context;
+        // Support both connectionId (new) and authenticationId (deprecated)
+        const resolvedConnectionId = options.connectionId ?? options.authenticationId;
+        if (!resolvedConnectionId) {
+            throw new Error("connectionId is required");
+        }
+        return await api.get(`/api/v0/connections/${encodeURIComponent(String(resolvedConnectionId))}`);
+    }
+    const getConnectionDefinition = createFunction(getConnection, GetConnectionParamSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, getConnection.name));
+    return {
+        getConnection: getConnectionDefinition,
+        context: {
+            meta: {
+                getConnection: {
+                    categories: ["connection"],
+                    type: "item",
+                    itemType: "Connection",
+                    inputSchema: GetConnectionParamSchema,
+                    outputSchema: ConnectionItemSchema,
+                    resolvers: {
+                        connectionId: connectionIdGenericResolver,
+                    },
+                    deprecatedParameters: ["authenticationId"],
+                },
+            },
+        },
+    };
+};

package/dist/plugins/getConnection/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/getConnection/index.test.ts"],"names":[],"mappings":""}