@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/plugins/listInputFields/index.ts

@@ -1,294 +0,0 @@
-import type { Plugin, GetSdkType } from "../../types/plugin";
-import type { ApiClient } from "../../api";
-import type { NeedsRequest, NeedsResponse, Need } from "../../api/types";
-import type {
-  InputFieldItem,
-  InfoFieldItem,
-  FieldsetItem,
-  RootFieldItem,
-} from "../../types/domain";
-import {
-  ListInputFieldsSchema,
-  type ListInputFieldsOptions,
-  type ListInputFieldsPage,
-} from "./schemas";
-import { ZapierConfigurationError, ZapierApiError } from "../../types/errors";
-import { createPaginatedFunction } from "../../utils/function-utils";
-import type { GetAppPluginProvides } from "../getApp";
-import type { GetActionPluginProvides } from "../getAction";
-import type { GetVersionedImplementationId } from "../manifest/schemas";
-import {
-  appKeyResolver,
-  actionTypeResolver,
-  actionKeyResolver,
-  authenticationIdResolver,
-  inputsAllOptionalResolver,
-} from "../../resolvers";
-import { RootFieldItemSchema } from "../../schemas/Field";
-import { toTitleCase } from "../../utils/string-utils";
-
-// Enums for input field transformation
-enum InputFieldType {
-  STRING = "STRING",
-  NUMBER = "NUMBER",
-  INTEGER = "INTEGER",
-  BOOLEAN = "BOOLEAN",
-  OBJECT = "OBJECT",
-  ARRAY = "ARRAY",
-}
-
-enum InputFieldFormat {
-  DATETIME = "DATETIME",
-  SELECT = "SELECT",
-  MULTILINE = "MULTILINE",
-  FILE = "FILE",
-  PASSWORD = "PASSWORD",
-  CODE = "CODE",
-}
-
-enum ItemsType {
-  STRING = "STRING",
-  NUMBER = "NUMBER",
-  INTEGER = "INTEGER",
-  BOOLEAN = "BOOLEAN",
-  OBJECT = "OBJECT",
-}
-
-// Transformation helper functions
-function getInputFieldTypeFromNeed(need: Need): InputFieldType {
-  if (need.list) {
-    return InputFieldType.ARRAY;
-  }
-
-  const typeMap: Record<string, InputFieldType> = {
-    string: InputFieldType.STRING,
-    decimal: InputFieldType.NUMBER,
-    integer: InputFieldType.INTEGER,
-    boolean: InputFieldType.BOOLEAN,
-    dict: InputFieldType.OBJECT,
-  };
-
-  return typeMap[need.type || ""] || InputFieldType.STRING;
-}
-
-function getInputFieldFormatFromNeed(need: Need): InputFieldFormat | undefined {
-  if (need.prefill || need.choices) {
-    return InputFieldFormat.SELECT;
-  }
-
-  const formatMap: Record<string, InputFieldFormat> = {
-    text: InputFieldFormat.MULTILINE,
-    datetime: InputFieldFormat.DATETIME,
-    file: InputFieldFormat.FILE,
-    password: InputFieldFormat.PASSWORD,
-    code: InputFieldFormat.CODE,
-  };
-
-  return formatMap[need.type || ""];
-}
-
-function getItemsTypeFromNeed(need: Need): ItemsType | undefined {
-  if (!need.list) {
-    return undefined;
-  }
-
-  const typeMap: Record<string, ItemsType> = {
-    string: ItemsType.STRING,
-    decimal: ItemsType.NUMBER,
-    integer: ItemsType.INTEGER,
-    boolean: ItemsType.BOOLEAN,
-    dict: ItemsType.OBJECT,
-  };
-
-  return typeMap[need.type || ""] || ItemsType.STRING;
-}
-
-// Transform Need to InputFieldItem
-function transformNeedToInputFieldItem(need: Need): InputFieldItem {
-  const itemsType = getItemsTypeFromNeed(need);
-
-  return {
-    type: "input_field",
-    key: need.key,
-    default_value: need.default || "",
-    depends_on: need.depends_on || [],
-    description: need.help_text || "",
-    invalidates_input_fields: need.alters_custom_fields || false,
-    is_required: need.required || false,
-    placeholder: need.placeholder || "",
-    title: need.label || "",
-    value_type: getInputFieldTypeFromNeed(need),
-    format: getInputFieldFormatFromNeed(need),
-    items: itemsType ? { type: itemsType } : undefined,
-  };
-}
-
-// Transform Need to InfoFieldItem (for copy fields)
-function transformNeedToInfoFieldItem(need: Need): InfoFieldItem {
-  return {
-    type: "info_field",
-    key: need.key,
-    description: need.help_text || "",
-    title: need.label,
-  };
-}
-
-// Transform needs to fields (similar to partnerapi compute_root_fieldset_from_needs)
-function transformNeedsToFields(needs: Need[]): RootFieldItem[] {
-  const rootFields: (InputFieldItem | InfoFieldItem | FieldsetItem)[] = [];
-  const fieldsetMap = new Map<string, FieldsetItem>();
-
-  for (const need of needs) {
-    if (need.computed) {
-      // Computed needs (i.e zap_id for CodeAPI steps) are not shown by the
-      // editor, hide them here too.
-      continue;
-    }
-
-    // If parent_key is set, we need to ensure that a corresponding
-    // fieldset exists, since we'll be adding this need to that fieldset
-    if (need.parent_key) {
-      let fieldset = fieldsetMap.get(need.parent_key);
-      if (!fieldset) {
-        fieldset = {
-          type: "fieldset",
-          key: need.parent_key,
-          title: toTitleCase(need.parent_key),
-          fields: [],
-        };
-        fieldsetMap.set(need.parent_key, fieldset);
-        rootFields.push(fieldset);
-      }
-
-      // Add field to fieldset
-      if (need.type === "copy" && need.help_text) {
-        fieldset.fields.push(transformNeedToInfoFieldItem(need));
-      } else {
-        fieldset.fields.push(transformNeedToInputFieldItem(need));
-      }
-    } else {
-      // Add field to root
-      if (need.type === "copy" && need.help_text) {
-        rootFields.push(transformNeedToInfoFieldItem(need));
-      } else {
-        rootFields.push(transformNeedToInputFieldItem(need));
-      }
-    }
-  }
-
-  return rootFields;
-}
-
-export interface ListInputFieldsPluginProvides {
-  listInputFields: (options?: ListInputFieldsOptions) => Promise<{
-    data: RootFieldItem[];
-    nextCursor?: string;
-  }> &
-    AsyncIterable<{ data: RootFieldItem[]; nextCursor?: string }> & {
-      items(): AsyncIterable<InputFieldItem | InfoFieldItem | FieldsetItem>;
-    };
-  context: {
-    meta: {
-      listInputFields: {
-        inputSchema: typeof ListInputFieldsSchema;
-      };
-    };
-  };
-}
-
-export const listInputFieldsPlugin: Plugin<
-  GetSdkType<GetAppPluginProvides & GetActionPluginProvides>, // requires getApp and getAction in SDK
-  {
-    api: ApiClient;
-    getVersionedImplementationId: GetVersionedImplementationId;
-  }, // requires api and getVersionedImplementationId in context
-  ListInputFieldsPluginProvides
-> = ({ sdk, context }) => {
-  const listInputFields = createPaginatedFunction(
-    async function listInputFieldsPage(
-      options: ListInputFieldsOptions & { cursor?: string } & {
-        pageSize: number;
-      },
-    ): Promise<ListInputFieldsPage> {
-      // Note: This function ignores pageSize and cursor since it's not actually paginated internally
-      const { api, getVersionedImplementationId } = context;
-
-      // Extract parameters
-      const { appKey, actionKey, actionType, authenticationId, inputs } =
-        options;
-
-      // Use the manifest plugin
-      const selectedApi = await getVersionedImplementationId(appKey);
-
-      if (!selectedApi) {
-        throw new ZapierConfigurationError(
-          "No current_implementation_id found for app",
-          { configType: "current_implementation_id" },
-        );
-      }
-
-      const { data: action } = await sdk.getAction({
-        appKey,
-        actionType,
-        actionKey,
-      });
-
-      // Build needs request
-      const needsRequest: NeedsRequest = {
-        selected_api: selectedApi,
-        action: action.key,
-        type_of: actionType,
-        params: inputs || {},
-      };
-
-      // Only include authentication_id if it's not null (skip authentication when null)
-      if (authenticationId !== null) {
-        needsRequest.authentication_id = authenticationId;
-      }
-
-      const needsData: NeedsResponse = await api.post(
-        "/api/v4/implementations/needs/",
-        needsRequest,
-      );
-
-      if (!needsData.success) {
-        throw new ZapierApiError(
-          `Failed to get action fields: ${
-            needsData.errors?.join(", ") || "Unknown error"
-          }`,
-        );
-      }
-
-      // Transform Need objects to Root Fieldset with proper nesting
-      const rootFieldset = transformNeedsToFields(needsData.needs || []);
-
-      return {
-        data: rootFieldset,
-        nextCursor: undefined, // No pagination needed since we return all input fields
-      };
-    },
-    ListInputFieldsSchema,
-  );
-
-  return {
-    listInputFields,
-    context: {
-      meta: {
-        listInputFields: {
-          categories: ["action"],
-          type: "list",
-          itemType: "RootFieldItem",
-          inputSchema: ListInputFieldsSchema,
-          outputSchema: RootFieldItemSchema,
-          resolvers: {
-            appKey: appKeyResolver,
-            actionType: actionTypeResolver,
-            actionKey: actionKeyResolver,
-            authenticationId: authenticationIdResolver,
-            inputs: inputsAllOptionalResolver,
-          },
-        },
-      },
-    },
-  };
-};

package/src/plugins/listInputFields/schemas.ts

@@ -1,68 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-  ActionKeyPropertySchema,
-  AuthenticationIdPropertySchema,
-  InputsPropertySchema,
-} from "../../types/properties";
-import type { RootFieldItem } from "../../types/domain";
-import type { PaginatedSdkFunction } from "../../types/functions";
-import type {
-  ZapierConfigurationError,
-  ZapierApiError,
-  ZapierAuthenticationError,
-  ZapierAppNotFoundError,
-  ZapierValidationError,
-  ZapierUnknownError,
-} from "../../types/errors";
-
-// Pure Zod schema - no resolver metadata!
-export const ListInputFieldsSchema = z
-  .object({
-    appKey: AppKeyPropertySchema,
-    actionType: ActionTypePropertySchema,
-    actionKey: ActionKeyPropertySchema,
-    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
-    inputs: InputsPropertySchema.optional().describe(
-      "Current input values that may affect available fields",
-    ),
-    pageSize: z
-      .number()
-      .min(1)
-      .optional()
-      .describe("Number of input fields per page"),
-    maxItems: z
-      .number()
-      .min(1)
-      .optional()
-      .describe("Maximum total items to return across all pages"),
-    cursor: z.string().optional().describe("Cursor to start from"),
-  })
-  .describe("Get the input fields required for a specific action");
-
-// Type inferred from schema
-export type ListInputFieldsOptions = z.infer<typeof ListInputFieldsSchema>;
-
-// Error union for this function
-export type ListInputFieldsError =
-  | ZapierConfigurationError
-  | ZapierApiError
-  | ZapierAuthenticationError
-  | ZapierAppNotFoundError
-  | ZapierValidationError
-  | ZapierUnknownError;
-
-// Page result structure
-export interface ListInputFieldsPage {
-  data: RootFieldItem[];
-  nextCursor?: string;
-}
-
-// SDK function interface
-export interface ListInputFieldsSdkFunction {
-  listInputFields: PaginatedSdkFunction<
-    ListInputFieldsOptions,
-    RootFieldItem[]
-  >;
-}