@basis-theory-labs/cli 1.13.0 → 2.1.0

package/dist/runtime/state.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLL_TIMEOUT = exports.POLL_INTERVAL = exports.needsPolling = exports.waitForResourceState = void 0;
+const core_1 = require("@oclif/core");
+const POLL_INTERVAL = 2000; // 2 seconds
+exports.POLL_INTERVAL = POLL_INTERVAL;
+const POLL_TIMEOUT = 600000; // 10 minutes
+exports.POLL_TIMEOUT = POLL_TIMEOUT;
+const formatErrorMessage = (resource, resourceType) => {
+    const { state, requested } = resource;
+    const resourceName = resourceType === 'reactor' ? 'Reactor' : 'Proxy';
+    const parts = [`${resourceName} reached ${state} state`];
+    if (requested === null || requested === void 0 ? void 0 : requested.errorCode) {
+        parts.push(`errorCode: ${requested.errorCode}`);
+    }
+    if (requested === null || requested === void 0 ? void 0 : requested.errorMessage) {
+        parts.push(`errorMessage: ${requested.errorMessage}`);
+    }
+    if (requested === null || requested === void 0 ? void 0 : requested.errorDetails) {
+        parts.push(`errorDetails: ${JSON.stringify(requested.errorDetails)}`);
+    }
+    return parts.join('\n');
+};
+const needsPolling = (state) => state === 'creating' || state === 'updating';
+exports.needsPolling = needsPolling;
+const formatElapsedTime = (startTime) => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const minutes = Math.floor(elapsed / 60);
+    const seconds = elapsed % 60;
+    if (minutes > 0) {
+        return `${minutes}m ${seconds}s`;
+    }
+    return `${seconds}s`;
+};
+const createTimer = (startTime, getState) => setInterval(() => {
+    const state = getState();
+    if (state) {
+        core_1.ux.action.status = `${state} (${formatElapsedTime(startTime)})`;
+    }
+}, 1000);
+const waitForResourceState = async (bt, resourceType, id, initialState) => {
+    // If initial state is provided and doesn't need polling, return immediately
+    if (initialState !== undefined && !needsPolling(initialState)) {
+        return;
+    }
+    const deadline = Date.now() + POLL_TIMEOUT;
+    const startTime = Date.now();
+    let currentState;
+    const timer = createTimer(startTime, () => currentState);
+    core_1.ux.action.start('Status');
+    /* eslint-disable no-await-in-loop */
+    try {
+        while (Date.now() < deadline) {
+            let resource;
+            try {
+                resource = await (resourceType === 'reactor'
+                    ? bt.reactors.get(id)
+                    : bt.proxies.get(id));
+            }
+            catch (error) {
+                core_1.ux.action.stop(`error (${formatElapsedTime(startTime)})`);
+                throw new Error(`Failed to check ${resourceType} state: ${error.message}`);
+            }
+            currentState = resource.state;
+            core_1.ux.action.status = `${currentState} (${formatElapsedTime(startTime)})`;
+            if (currentState === 'active') {
+                core_1.ux.action.stop(`ready (${formatElapsedTime(startTime)})`);
+                return;
+            }
+            if (currentState === 'failed' || currentState === 'outdated') {
+                core_1.ux.action.stop(`failed (${formatElapsedTime(startTime)})`);
+                throw new Error(formatErrorMessage(resource, resourceType));
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, POLL_INTERVAL);
+            });
+        }
+        core_1.ux.action.stop(`timeout (${formatElapsedTime(startTime)})`);
+        throw new Error(`Timeout waiting for ${resourceType} to reach final state`);
+    }
+    finally {
+        clearInterval(timer);
+    }
+    /* eslint-enable no-await-in-loop */
+};
+exports.waitForResourceState = waitForResourceState;

package/dist/runtime/utils.d.ts

@@ -0,0 +1,34 @@
+import type { BasisTheory } from '@basis-theory/node-sdk';
+declare const LEGACY_RUNTIME_IMAGE = "node-bt";
+declare const CONFIGURABLE_RUNTIME_IMAGES: readonly ["node22"];
+declare const VALID_RUNTIME_IMAGES: readonly ["node-bt", "node22"];
+declare const isLegacyRuntimeImage: (image: string | undefined) => boolean;
+declare const validateRuntimeImage: (image: string | undefined) => void;
+declare const CONFIGURABLE_RUNTIME_FLAGS: readonly ["timeout", "resources", "warm-concurrency", "permissions", "dependencies"];
+interface RuntimeFlagProps {
+    image?: string;
+    dependencies?: string;
+    timeout?: number;
+    warmConcurrency?: number;
+    resources?: string;
+    permissions?: string[];
+}
+interface RuntimeFlags {
+    image?: string;
+    timeout?: number;
+    'warm-concurrency'?: number;
+    resources?: string;
+    dependencies?: string;
+    permissions?: string[];
+}
+interface ConfigurableRuntimeOptions {
+    timeout?: number;
+    warmConcurrency?: number;
+    resources?: string;
+    dependencies?: string;
+    permissions?: string[];
+}
+declare const buildRuntime: (props: RuntimeFlagProps) => BasisTheory.Runtime | undefined;
+declare const promptRuntimeOptions: (flags: RuntimeFlags, labelPrefix?: string) => Promise<ConfigurableRuntimeOptions>;
+declare const promptRuntimeImage: (image: string | undefined, message?: string) => Promise<string>;
+export { LEGACY_RUNTIME_IMAGE, CONFIGURABLE_RUNTIME_IMAGES, VALID_RUNTIME_IMAGES, CONFIGURABLE_RUNTIME_FLAGS, isLegacyRuntimeImage, validateRuntimeImage, buildRuntime, promptRuntimeOptions, promptRuntimeImage, type RuntimeFlagProps, type RuntimeFlags, type ConfigurableRuntimeOptions, };

package/dist/runtime/utils.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptRuntimeImage = exports.promptRuntimeOptions = exports.buildRuntime = exports.validateRuntimeImage = exports.isLegacyRuntimeImage = exports.CONFIGURABLE_RUNTIME_FLAGS = exports.VALID_RUNTIME_IMAGES = exports.CONFIGURABLE_RUNTIME_IMAGES = exports.LEGACY_RUNTIME_IMAGE = void 0;
+const files_1 = require("../files");
+const utils_1 = require("../utils");
+const LEGACY_RUNTIME_IMAGE = 'node-bt';
+exports.LEGACY_RUNTIME_IMAGE = LEGACY_RUNTIME_IMAGE;
+const CONFIGURABLE_RUNTIME_IMAGES = ['node22'];
+exports.CONFIGURABLE_RUNTIME_IMAGES = CONFIGURABLE_RUNTIME_IMAGES;
+const VALID_RUNTIME_IMAGES = [
+    LEGACY_RUNTIME_IMAGE,
+    ...CONFIGURABLE_RUNTIME_IMAGES,
+];
+exports.VALID_RUNTIME_IMAGES = VALID_RUNTIME_IMAGES;
+const isLegacyRuntimeImage = (image) => image === undefined || image === LEGACY_RUNTIME_IMAGE;
+exports.isLegacyRuntimeImage = isLegacyRuntimeImage;
+const validateRuntimeImage = (image) => {
+    if (image === undefined) {
+        return;
+    }
+    if (!VALID_RUNTIME_IMAGES.includes(image)) {
+        throw new Error(`Invalid runtime image "${image}". Valid options: ${VALID_RUNTIME_IMAGES.join(', ')}`);
+    }
+};
+exports.validateRuntimeImage = validateRuntimeImage;
+const CONFIGURABLE_RUNTIME_FLAGS = [
+    'timeout',
+    'resources',
+    'warm-concurrency',
+    'permissions',
+    'dependencies',
+];
+exports.CONFIGURABLE_RUNTIME_FLAGS = CONFIGURABLE_RUNTIME_FLAGS;
+const buildRuntime = (props) => {
+    const { image, dependencies, timeout, warmConcurrency, resources, permissions, } = props;
+    if (!image &&
+        !dependencies &&
+        !timeout &&
+        !warmConcurrency &&
+        !resources &&
+        !(permissions === null || permissions === void 0 ? void 0 : permissions.length)) {
+        return undefined;
+    }
+    let parsedDependencies;
+    if (dependencies) {
+        try {
+            parsedDependencies = JSON.parse((0, files_1.readFileContents)(dependencies));
+        }
+        catch (error) {
+            throw new Error(`Failed to parse dependencies file "${dependencies}": ${error.message}`);
+        }
+    }
+    const runtime = {};
+    if (image) {
+        runtime.image = image;
+    }
+    if (parsedDependencies) {
+        runtime.dependencies = parsedDependencies;
+    }
+    if (timeout !== undefined) {
+        runtime.timeout = timeout;
+    }
+    if (warmConcurrency !== undefined) {
+        runtime.warmConcurrency = warmConcurrency;
+    }
+    if (resources) {
+        runtime.resources = resources;
+    }
+    if (permissions === null || permissions === void 0 ? void 0 : permissions.length) {
+        runtime.permissions = permissions;
+    }
+    return runtime;
+};
+exports.buildRuntime = buildRuntime;
+const promptRuntimeOptions = async (flags, labelPrefix) => {
+    const prefix = labelPrefix ? `${labelPrefix}: ` : '';
+    const timeout = await (0, utils_1.promptIntegerIfUndefined)(flags.timeout, {
+        message: `${prefix}Timeout in seconds (1-30, press Enter for default: 10):`,
+        min: 1,
+        max: 30,
+    });
+    const warmConcurrency = await (0, utils_1.promptIntegerIfUndefined)(flags['warm-concurrency'], {
+        message: `${prefix}Warm concurrency (0-1, press Enter for default: 0):`,
+        min: 0,
+        max: 1,
+    });
+    const resources = await (0, utils_1.promptSelectIfUndefined)(flags.resources, {
+        message: `${prefix}Resource tier:`,
+        choices: [
+            {
+                value: 'standard',
+                name: 'standard (default)',
+            },
+            {
+                value: 'large',
+                name: 'large',
+            },
+            {
+                value: 'xlarge',
+                name: 'xlarge',
+            },
+        ],
+    });
+    const dependencies = await (0, utils_1.promptStringIfUndefined)(flags.dependencies, {
+        message: `${prefix}(Optional) Dependencies file path (JSON format):`,
+    });
+    const permissions = await (0, utils_1.promptCommaSeparatedIfUndefined)(flags.permissions, {
+        message: `${prefix}(Optional) Permissions (comma-separated, e.g. token:read, token:create):`,
+    });
+    return {
+        timeout,
+        warmConcurrency,
+        resources,
+        dependencies: dependencies || undefined,
+        permissions,
+    };
+};
+exports.promptRuntimeOptions = promptRuntimeOptions;
+const promptRuntimeImage = (image, message = 'Which runtime do you want to use?') => (0, utils_1.promptSelectIfUndefined)(image, {
+    message,
+    choices: [
+        {
+            value: LEGACY_RUNTIME_IMAGE,
+            name: `${LEGACY_RUNTIME_IMAGE} (legacy)`,
+        },
+        ...CONFIGURABLE_RUNTIME_IMAGES.map((runtime) => ({
+            value: runtime,
+            name: `${runtime} (configurable)`,
+        })),
+    ],
+});
+exports.promptRuntimeImage = promptRuntimeImage;

package/dist/utils.d.ts

@@ -1,15 +1,25 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { PaginatedList } from '@basis-theory/basis-theory-js/types/sdk';
 import checkbox from '@inquirer/checkbox';
 import confirm from '@inquirer/confirm';
 import input from '@inquirer/input';
 import select from '@inquirer/select';
+interface PaginatedList<T> {
+    data: T[];
+    page: number;
+    hasNextPage: boolean;
+}
 declare const selectOrNavigate: <T>(list: PaginatedList<T>, prop: string) => Promise<T | "previous" | "next">;
 declare const promptStringIfUndefined: (value: string | undefined, options: Parameters<typeof input>[0]) => Promise<string>;
 declare const promptSelectIfUndefined: (value: string | undefined, options: Parameters<typeof select>[0]) => Promise<string>;
 declare const promptCheckboxIfUndefined: (value: string[] | undefined, options: Parameters<typeof checkbox>[0]) => Promise<string[]>;
 declare const promptUrlIfUndefined: (value: URL | undefined, options: Parameters<typeof input>[0]) => Promise<URL>;
 declare const promptBooleanIfUndefined: (value: boolean | undefined, options: Parameters<typeof confirm>[0]) => Promise<boolean>;
+declare const promptIntegerIfUndefined: (value: number | undefined, options: {
+    message: string;
+    min?: number;
+    max?: number;
+}) => Promise<number | undefined>;
+declare const promptCommaSeparatedIfUndefined: (value: string[] | undefined, options: Parameters<typeof input>[0]) => Promise<string[] | undefined>;
 declare const cleanUpOnExit: (action: () => unknown) => typeof process;
-export { selectOrNavigate, promptStringIfUndefined, promptSelectIfUndefined, promptCheckboxIfUndefined, promptUrlIfUndefined, promptBooleanIfUndefined, cleanUpOnExit, };
+export { selectOrNavigate, promptStringIfUndefined, promptSelectIfUndefined, promptCheckboxIfUndefined, promptUrlIfUndefined, promptBooleanIfUndefined, promptIntegerIfUndefined, promptCommaSeparatedIfUndefined, cleanUpOnExit, PaginatedList, };

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanUpOnExit = exports.promptBooleanIfUndefined = exports.promptUrlIfUndefined = exports.promptCheckboxIfUndefined = exports.promptSelectIfUndefined = exports.promptStringIfUndefined = exports.selectOrNavigate = void 0;
+exports.cleanUpOnExit = exports.promptCommaSeparatedIfUndefined = exports.promptIntegerIfUndefined = exports.promptBooleanIfUndefined = exports.promptUrlIfUndefined = exports.promptCheckboxIfUndefined = exports.promptSelectIfUndefined = exports.promptStringIfUndefined = exports.selectOrNavigate = void 0;
 const tslib_1 = require("tslib");
 const checkbox_1 = tslib_1.__importDefault(require("@inquirer/checkbox"));
 const confirm_1 = tslib_1.__importDefault(require("@inquirer/confirm"));
@@ -8,10 +8,10 @@ const input_1 = tslib_1.__importDefault(require("@inquirer/input"));
 const select_1 = tslib_1.__importDefault(require("@inquirer/select"));
 const core_1 = require("@oclif/core");
 const selectOrNavigate = async (list, prop) => {
-    const { data, pagination } = list;
+    const { data, page, hasNextPage } = list;
     let prompt = `Select one (${prop})`;
-    const hasNext = pagination.totalPages > pagination.pageNumber;
-    const hasPrevious = pagination.pageNumber > 1;
+    const hasNext = hasNextPage;
+    const hasPrevious = page > 1;
     if (hasPrevious) {
         prompt += " or 'p' for previous page ";
     }
@@ -82,6 +82,46 @@ const promptBooleanIfUndefined = (value, options) => {
     return (0, confirm_1.default)(options);
 };
 exports.promptBooleanIfUndefined = promptBooleanIfUndefined;
+const promptIntegerIfUndefined = async (value, options) => {
+    if (value !== undefined) {
+        return value;
+    }
+    const result = await (0, input_1.default)({
+        message: options.message,
+        validate: (val) => {
+            if (!val.trim()) {
+                return true;
+            } // Allow empty for optional
+            const num = Number(val);
+            if (Number.isNaN(num) || !Number.isInteger(num)) {
+                return 'Please enter a valid integer';
+            }
+            if (options.min !== undefined && num < options.min) {
+                return `Value must be at least ${options.min}`;
+            }
+            if (options.max !== undefined && num > options.max) {
+                return `Value must be at most ${options.max}`;
+            }
+            return true;
+        },
+    });
+    return result.trim() ? Number(result) : undefined;
+};
+exports.promptIntegerIfUndefined = promptIntegerIfUndefined;
+const promptCommaSeparatedIfUndefined = async (value, options) => {
+    if (value && value.length > 0) {
+        return value;
+    }
+    const result = await (0, input_1.default)(options);
+    if (!result.trim()) {
+        return undefined;
+    }
+    return result
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+};
+exports.promptCommaSeparatedIfUndefined = promptCommaSeparatedIfUndefined;
 const cleanUpOnExit = (action) => process.on('SIGINT', async () => {
     await action();
     process.exit(1);