@zapier/zapier-sdk-cli 0.1.0 → 0.2.0

package/src/utils/auth/refreshJWT.ts

@@ -0,0 +1,50 @@
+import { AUTH_MODE_HEADER, LOGIN_CLIENT_ID, ZAPIER_BASE } from "../constants";
+import api from "../api/client";
+import serializeAsync from "../serializeAsync";
+import { spinPromise } from "../spinner";
+import getAuthState from "./getAuthState";
+import updateLogin from "./updateLogin";
+import logout from "./logout";
+
+const refreshJWT = async (): Promise<string> => {
+  const state = getAuthState();
+
+  if (state.status === "logged-out") {
+    throw new Error("Unexpected call to refreshJWT while logged out.");
+  }
+
+  try {
+    const { data } = await spinPromise(
+      api.post<{
+        access_token: string;
+        refresh_token: string;
+        expires_in: number;
+      }>(
+        `${ZAPIER_BASE}/oauth/token/`,
+        {
+          client_id: LOGIN_CLIENT_ID,
+          refresh_token: state.refresh_token,
+          grant_type: "refresh_token",
+        },
+        {
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            [AUTH_MODE_HEADER]: "no",
+          },
+        },
+      ),
+      "Refreshing your token...",
+    );
+
+    updateLogin(data);
+
+    return data.access_token;
+  } catch (e) {
+    // Force logout
+    logout();
+
+    throw e;
+  }
+};
+
+export default serializeAsync(refreshJWT);

package/src/utils/auth/updateLogin.ts

@@ -0,0 +1,19 @@
+import { config } from "../config";
+
+interface LoginData {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+}
+
+const updateLogin = ({
+  access_token: accessToken,
+  refresh_token: refreshToken,
+  expires_in: expiresIn,
+}: LoginData) => {
+  config.set("login_jwt", accessToken);
+  config.set("login_refresh_token", refreshToken);
+  config.set("login_expires_at", Date.now() + expiresIn * 1000);
+};
+
+export default updateLogin;

package/src/utils/cli-generator.ts

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import { z } from "zod";
-import { ZapierSdk, hasResolver } from "@zapier/zapier-sdk";
+import { ZapierSdk, hasResolver, isPositional } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
 import { createPager } from "./pager";
 import { formatItemsFromSchema } from "./schema-formatter";
@@ -46,6 +46,7 @@ interface CliParameter {
   default?: any;
   choices?: string[];
   hasResolver?: boolean;
+  isPositional?: boolean;
 }
 
 // ============================================================================
@@ -118,6 +119,7 @@ function analyzeZodField(
     default: defaultValue,
     choices,
     hasResolver: hasResolver(name),
+    isPositional: isPositional(schema),
   };
 }
 
@@ -309,6 +311,12 @@ function addCommand(
         `<${kebabName}>`,
         param.description || `${kebabName} parameter`,
       );
+    } else if (param.isPositional) {
+      // Optional parameters marked as positional become optional positional arguments
+      command.argument(
+        `[${kebabName}]`,
+        param.description || `${kebabName} parameter`,
+      );
     } else {
       // Optional parameters become flags (whether they have resolvers or not)
       const flags = [`--${kebabName}`];
@@ -339,10 +347,13 @@ function convertCliArgsToSdkParams(
 ): Record<string, any> {
   const sdkParams: Record<string, any> = {};
 
-  // Handle positional arguments (required parameters only, whether they have resolvers or not)
+  // Handle positional arguments (required parameters or optional positional parameters)
   let argIndex = 0;
   parameters.forEach((param) => {
-    if (param.required && argIndex < positionalArgs.length) {
+    if (
+      (param.required || param.isPositional) &&
+      argIndex < positionalArgs.length
+    ) {
       // Use the original camelCase parameter name for the SDK
       sdkParams[param.name] = convertValue(
         positionalArgs[argIndex],

package/src/utils/config.ts

@@ -0,0 +1,3 @@
+import Conf from "conf";
+
+export const config = new Conf({ projectName: "zapier-sdk-cli" });

package/src/utils/constants.ts

@@ -0,0 +1,9 @@
+export const ZAPIER_BASE = "https://zapier.com";
+
+// OAuth client ID for zapier-sdk CLI
+export const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+
+export const LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+export const LOGIN_TIMEOUT_MS = 300000; // 5 minutes
+
+export const AUTH_MODE_HEADER = "X-Auth";

package/src/utils/getCallablePromise.ts

@@ -0,0 +1,21 @@
+const getCallablePromise = <T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason: unknown) => void;
+} => {
+  let resolve: (value: T) => void = () => {};
+  let reject: (reason: unknown) => void = () => {};
+
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+
+  return {
+    promise,
+    resolve,
+    reject,
+  };
+};
+
+export default getCallablePromise;

package/src/utils/getConfigPath.ts

@@ -0,0 +1,5 @@
+import { config } from "./config";
+
+export const getConfigPath = (): string => {
+  return config.path;
+};

package/src/utils/log.ts

@@ -0,0 +1,18 @@
+import chalk from "chalk";
+
+const log = {
+  info: (message: string, ...args: any[]) => {
+    console.log(chalk.blue("ℹ"), message, ...args);
+  },
+  error: (message: string, ...args: any[]) => {
+    console.error(chalk.red("✖"), message, ...args);
+  },
+  success: (message: string, ...args: any[]) => {
+    console.log(chalk.green("✓"), message, ...args);
+  },
+  warn: (message: string, ...args: any[]) => {
+    console.log(chalk.yellow("⚠"), message, ...args);
+  },
+};
+
+export default log;

package/src/utils/serializeAsync.ts

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+
+const promises: Record<string, Promise<unknown>> = {};
+
+const serializeAsync =
+  <R, A extends []>(
+    fn: (...args: A) => Promise<R>,
+  ): ((...args: A) => Promise<R>) =>
+  async (...args: A): Promise<R> => {
+    const hash = createHash("sha256")
+      .update(fn.toString(), "utf8")
+      .digest()
+      .toString("hex");
+
+    const promise = promises[hash];
+
+    if (!promise) {
+      promises[hash] = fn(...args).finally(() => {
+        delete promises[hash];
+      });
+    }
+
+    return promises[hash] as Promise<R>;
+  };
+
+export default serializeAsync;

package/src/utils/spinner.ts

@@ -0,0 +1,16 @@
+import ora from "ora";
+
+export const spinPromise = async <T>(
+  promise: Promise<T>,
+  text: string,
+): Promise<T> => {
+  const spinner = ora(text).start();
+  try {
+    const result = await promise;
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+};

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "node",
+    "module": "ES2020",
+    "moduleResolution": "bundler",
     "strict": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,