zapier-platform-cli 16.3.0 → 16.4.0

package/src/generators/templates/openai/dynamic_dropdowns/list_models.js

@@ -0,0 +1,24 @@
+const { API_URL } = require('../constants');
+
+const perform = async (z, bundle) => {
+  const response = await z.request({ url: `${API_URL}/models` });
+
+  const responseData = response.data;
+
+  return responseData.data.map((model) => ({
+    id: model.id,
+    name: model.id,
+  }));
+};
+
+module.exports = {
+  key: 'list_models',
+  noun: 'Model',
+  display: {
+    label: 'List of Models',
+    description:
+      'This is a hidden trigger, and is used in a Dynamic Dropdown of another trigger.',
+    hidden: true,
+  },
+  operation: { perform },
+};

package/src/generators/templates/openai/index.js

@@ -0,0 +1,33 @@
+/* eslint-disable camelcase */
+const authentication = require('./authentication');
+const middleware = require('./middleware');
+const dynamic_dropdowns = require('./dynamic_dropdowns');
+const creates = require('./creates');
+
+module.exports = {
+  // This is just shorthand to reference the installed dependencies you have.
+  // Zapier will need to know these before we can upload.
+  version: require('./package.json').version,
+  platformVersion: require('zapier-platform-core').version,
+
+  authentication,
+
+  beforeRequest: [...middleware.befores],
+
+  afterResponse: [...middleware.afters],
+
+  // If you want your trigger to show up, you better include it here!
+  triggers: {
+    ...dynamic_dropdowns,
+  },
+
+  // If you want your searches to show up, you better include it here!
+  searches: {},
+
+  // If you want your creates to show up, you better include it here!
+  creates: {
+    ...creates,
+  },
+
+  resources: {},
+};

package/src/generators/templates/openai/middleware.js

@@ -0,0 +1,50 @@
+/* eslint-disable camelcase */
+// This function runs after every outbound request. You can use it to check for
+// errors or modify the response. You can have as many as you need. They'll need
+// to each be registered in your index.js file.
+const handleBadResponses = (response, z, bundle) => {
+  if (response.data.error) {
+    throw new z.errors.Error(
+      response.data.error.message,
+      response.data.error.code,
+      response.status,
+    );
+  }
+
+  return response;
+};
+
+const includeOrgId = (request, z, bundle) => {
+  const { organization_id } = bundle.authData;
+  if (organization_id) {
+    request.headers['OpenAI-Organization'] = organization_id;
+  }
+  return request;
+};
+
+// This function runs before every outbound request. You can have as many as you
+// need. They'll need to each be registered in your index.js file.
+const includeApiKey = (request, z, bundle) => {
+  const { api_key } = bundle.authData;
+  if (api_key) {
+    // Use these lines to include the API key in the querystring
+    //   request.params = request.params || {};
+    //   request.params.api_key = api_key;
+
+    // If you want to include the API key in the header:
+    request.headers.Authorization = `Bearer ${api_key}`;
+  }
+
+  return request;
+};
+
+const jsonHeaders = (request) => {
+  request.headers['Content-Type'] = 'application/json';
+  request.headers.Accept = 'application/json';
+  return request;
+};
+
+module.exports = {
+  befores: [includeApiKey, includeOrgId, jsonHeaders],
+  afters: [handleBadResponses],
+};

package/src/generators/templates/openai/samples/chat.json

@@ -0,0 +1,29 @@
+{
+  "id": "chatcmpl-123",
+  "object": "chat.completion",
+  "created": 1677652288,
+  "model": "gpt-4o-mini",
+  "system_fingerprint": "fp_44709d6fcb",
+  "choices": [
+    {
+      "index": 0,
+      "message": {
+        "role": "assistant",
+        "content": "\n\nHello there, how may I assist you today?"
+      },
+      "logprobs": null,
+      "finish_reason": "stop"
+    }
+  ],
+  "service_tier": "default",
+  "usage": {
+    "prompt_tokens": 9,
+    "completion_tokens": 12,
+    "total_tokens": 21,
+    "completion_tokens_details": {
+      "reasoning_tokens": 0,
+      "accepted_prediction_tokens": 0,
+      "rejected_prediction_tokens": 0
+    }
+  }
+}

package/src/generators/templates/openai/test/authentication.test.js

@@ -0,0 +1,66 @@
+/* globals describe, it, expect */
+/* eslint-disable no-undef */
+
+const App = require('../index');
+
+describe('custom auth', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('passes authentication and returns json', async () => {
+    const bundle = {
+      authData: {
+        api_key: 'secret',
+      },
+    };
+
+    // Mock successful response
+    const mockResponse = {
+      status: 200,
+      data: {
+        email: 'test@example.com',
+      },
+    };
+
+    // Mock the request client
+    const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+    const z = {
+      request: mockRequest,
+    };
+
+    const response = await App.authentication.test(z, bundle);
+
+    expect(mockRequest).toHaveBeenCalledTimes(1);
+    expect(mockRequest).toHaveBeenCalledWith({
+      url: expect.stringContaining('/me'),
+    });
+    expect(response.status).toBe(200);
+    expect(response.data).toHaveProperty('email', 'test@example.com');
+  });
+
+  it('fails on bad auth', async () => {
+    const bundle = {
+      authData: {
+        api_key: 'bad',
+      },
+    };
+
+    // Mock failed response
+    const mockRequest = jest
+      .fn()
+      .mockRejectedValue(new Error('Incorrect API key provided'));
+    const z = {
+      request: mockRequest,
+    };
+
+    try {
+      await App.authentication.test(z, bundle);
+    } catch (error) {
+      expect(mockRequest).toHaveBeenCalledTimes(1);
+      expect(error.message).toContain('Incorrect API key provided');
+      return;
+    }
+    throw new Error('appTester should have thrown');
+  });
+});

package/src/generators/templates/openai/test/chat_completion.test.js

@@ -0,0 +1,150 @@
+/* globals describe, it, expect */
+/* eslint-disable no-undef */
+
+const chatCompletion = require('../creates/chat_completion');
+const { DEFAULT_MODEL } = require('../constants');
+
+describe('chat_completion', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('creates a basic chat completion', async () => {
+    const bundle = {
+      inputData: {
+        user_message: 'Hello, how are you?',
+        model: DEFAULT_MODEL,
+      },
+    };
+
+    const mockResponse = {
+      data: {
+        id: 'chatcmpl-123',
+        model: DEFAULT_MODEL,
+        usage: {
+          prompt_tokens: 20,
+          completion_tokens: 15,
+          total_tokens: 35,
+        },
+        choices: [
+          {
+            message: {
+              content: 'I am doing well, thank you for asking!',
+            },
+          },
+        ],
+      },
+    };
+
+    const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+    const z = { request: mockRequest };
+
+    const result = await chatCompletion.operation.perform(z, bundle);
+
+    expect(mockRequest).toHaveBeenCalledTimes(1);
+    expect(mockRequest).toHaveBeenCalledWith({
+      url: expect.stringContaining('/chat/completions'),
+      method: 'POST',
+      body: expect.stringContaining(bundle.inputData.user_message),
+    });
+
+    expect(result).toEqual(mockResponse.data);
+  });
+
+  it('creates a chat completion with advanced options', async () => {
+    const bundle = {
+      inputData: {
+        user_message: 'Write a story',
+        model: DEFAULT_MODEL,
+        developer_message: 'You are a creative writer',
+        temperature: 0.9,
+        max_completion_tokens: 100,
+      },
+    };
+
+    const mockResponse = {
+      data: {
+        id: 'chatcmpl-456',
+        model: DEFAULT_MODEL,
+        usage: {
+          prompt_tokens: 25,
+          completion_tokens: 50,
+          total_tokens: 75,
+        },
+      },
+    };
+
+    const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+    const z = { request: mockRequest };
+
+    const result = await chatCompletion.operation.perform(z, bundle);
+
+    expect(mockRequest).toHaveBeenCalledTimes(1);
+    expect(mockRequest).toHaveBeenCalledWith({
+      url: expect.stringContaining('/chat/completions'),
+      method: 'POST',
+      body: expect.stringMatching(/temperature.*0.9/),
+    });
+
+    expect(result).toEqual(mockResponse.data);
+  });
+
+  it('creates a chat completion with image', async () => {
+    const bundle = {
+      inputData: {
+        user_message: 'Describe this image',
+        model: DEFAULT_MODEL,
+        files: ['https://example.com/image.jpg'],
+      },
+    };
+
+    const mockResponse = {
+      data: {
+        id: 'chatcmpl-789',
+        model: DEFAULT_MODEL,
+        usage: {
+          prompt_tokens: 30,
+          completion_tokens: 20,
+          total_tokens: 50,
+        },
+      },
+    };
+
+    const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+    const z = { request: mockRequest };
+
+    const result = await chatCompletion.operation.perform(z, bundle);
+
+    expect(mockRequest).toHaveBeenCalledTimes(1);
+    expect(mockRequest).toHaveBeenCalledWith({
+      url: expect.stringContaining('/chat/completions'),
+      method: 'POST',
+      body: expect.stringMatching(/image_url.*example.com/),
+    });
+
+    expect(result).toEqual(mockResponse.data);
+  });
+
+  it('handles API errors', async () => {
+    const bundle = {
+      inputData: {
+        user_message: 'Hello',
+        model: DEFAULT_MODEL,
+      },
+    };
+
+    const mockRequest = jest
+      .fn()
+      .mockRejectedValue(new Error('Invalid request'));
+    const z = { request: mockRequest };
+
+    try {
+      await chatCompletion.operation.perform(z, bundle);
+    } catch (error) {
+      expect(mockRequest).toHaveBeenCalledTimes(1);
+      expect(error.message).toContain('Invalid request');
+      return;
+    }
+    throw new Error('Should have thrown an error');
+  });
+});

package/src/generators/templates/openai/test/list_models.test.js

@@ -0,0 +1,51 @@
+/* globals describe, it, expect */
+/* eslint-disable no-undef */
+
+const listModels = require('../dynamic_dropdowns/list_models');
+
+describe('list_models', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns formatted list of models', async () => {
+    const mockResponse = {
+      data: {
+        data: [{ id: 'gpt-4' }, { id: 'gpt-3.5-turbo' }],
+      },
+    };
+
+    const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+    const z = { request: mockRequest };
+    const bundle = {};
+
+    const results = await listModels.operation.perform(z, bundle);
+
+    expect(mockRequest).toHaveBeenCalledTimes(1);
+    expect(mockRequest).toHaveBeenCalledWith({
+      url: expect.stringContaining('/models'),
+    });
+
+    expect(results).toEqual([
+      { id: 'gpt-4', name: 'gpt-4' },
+      { id: 'gpt-3.5-turbo', name: 'gpt-3.5-turbo' },
+    ]);
+  });
+
+  it('handles API errors', async () => {
+    const mockRequest = jest
+      .fn()
+      .mockRejectedValue(new Error('Failed to fetch models'));
+    const z = { request: mockRequest };
+    const bundle = {};
+
+    try {
+      await listModels.operation.perform(z, bundle);
+    } catch (error) {
+      expect(mockRequest).toHaveBeenCalledTimes(1);
+      expect(error.message).toContain('Failed to fetch models');
+      return;
+    }
+    throw new Error('Should have thrown an error');
+  });
+});

package/src/oclif/ZapierBaseCommand.js

@@ -18,7 +18,7 @@ class ZapierBaseCommand extends Command {
 
     if (this.flags.debug) {
       this.debug.enabled = true; // enables this.debug on the command
-      require('debug').enable('zapier:*'); // enables all further spawned functions, like API
+      require('debug').enable('zapier:*,oclif:zapier:*'); // enables all further spawned functions, like API
     }
 
     this.debug('argv is', this.argv);

package/src/oclif/commands/deprecate.js

@@ -1,15 +1,38 @@
 const BaseCommand = require('../ZapierBaseCommand');
-const { Args } = require('@oclif/core');
+const { Args, Flags } = require('@oclif/core');
 const { buildFlags } = require('../buildFlags');
+const colors = require('colors/safe');
 
-const { callAPI } = require('../../utils/api');
+const { callAPI, getSpecificVersionInfo } = require('../../utils/api');
 
 class DeprecateCommand extends BaseCommand {
   async perform() {
     const app = await this.getWritableApp();
     const { version, date } = this.args;
+
+    const versionInfo = await getSpecificVersionInfo(version);
+    const hasActiveUsers = versionInfo.user_count && versionInfo.user_count > 0;
+
+    this.log(
+      `${colors.yellow('Warning: Deprecation is an irreversible action that will eventually block access to this version.')}\n` +
+        `${colors.yellow('If all your changes are non-breaking, use `zapier migrate` instead to move users over to a newer version.')}\n`,
+    );
+
+    if (
+      !this.flags.force &&
+      !(await this.confirm(
+        'Are you sure you want to deprecate this version? This will notify users that their Zaps or other automations will stop working after the specified date.' +
+          (hasActiveUsers
+            ? `\n\nThis version has ${versionInfo.user_count} active user(s). Strongly consider migrating users to another version before deprecating!`
+            : ''),
+      ))
+    ) {
+      this.log('\nDeprecation cancelled.');
+      return;
+    }
+
     this.log(
-      `Preparing to deprecate version ${version} your app "${app.title}".\n`,
+      `\nPreparing to deprecate version ${version} your app "${app.title}".\n`,
     );
     const url = `/apps/${app.id}/versions/${version}/deprecate`;
     this.startSpinner(`Deprecating ${version}`);
@@ -21,12 +44,19 @@ class DeprecateCommand extends BaseCommand {
     });
     this.stopSpinner();
     this.log(
-      `\nWe'll let users know that this version is no longer recommended and will cease to work on ${date}.`,
+      `\nWe'll let users know that this version will cease to work on ${date}.`,
     );
   }
 }
 
-DeprecateCommand.flags = buildFlags();
+DeprecateCommand.flags = buildFlags({
+  commandFlags: {
+    force: Flags.boolean({
+      char: 'f',
+      description: 'Skip confirmation prompt. Use with caution.',
+    }),
+  },
+});
 DeprecateCommand.args = {
   version: Args.string({
     description: 'The version to deprecate.',
@@ -43,11 +73,15 @@ DeprecateCommand.description = `Mark a non-production version of your integratio
 
 Use this when an integration version will not be supported or start breaking at a known date.
 
-Zapier will send an email warning users of the deprecation once a date is set, they'll start seeing it as "Deprecated" in the UI, and once the deprecation date arrives, if the Zaps weren't updated, they'll be paused and the users will be emailed again explaining what happened.
+Zapier will immediately send emails warning users of the deprecation if a date less than 30 days in the future is set, otherwise the emails will be sent exactly 30 days before the configured deprecation date.
 
-After the deprecation date has passed it will be safe to delete that integration version.
+There are other side effects: they'll start seeing it as "Deprecated" in the UI, and once the deprecation date arrives, if the Zaps weren't updated, they'll be paused and the users will be emailed again explaining what happened.
 
-Do not use this if you have non-breaking changes, such as fixing help text.`;
+Do not use deprecation if you only have non-breaking changes, such as:
+- Fixing help text
+- Adding new triggers/actions
+- Improving existing functionality
+- other bug fixes that don't break existing automations.`;
 DeprecateCommand.skipValidInstallCheck = true;
 
 module.exports = DeprecateCommand;