@swell/cli 2.9.32 → 2.9.33

package/dist/commands/inspect/functions.js

@@ -1,4 +1,5 @@
 import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { slugFromInstalledApp } from '../../lib/apps/slug.js';
 function deriveTrigger(r) {
     if (r.cron?.schedule) {
         return `cron (${r.cron.schedule})`;
@@ -25,7 +26,7 @@ export default class Functions extends InspectResourceCommand {
     static summary = 'Functions with scheduling and trigger state.';
     static description = `Lists functions across all apps, grouped by app. Pass --app=<slug> or --app=. (current swell.json) to scope.
 
-List output: paste-back key + status (disabled, trigger, next cron run, last failure).
+List output: paste-back key + status (disabled or auto-disabled, failing since and failure count, the date it gets disabled, trigger, next cron run) and whether its app is inactive, which stops all of its functions. The detail view also shows the last failed delivery.
 
 Pass an identifier to view a single record as JSON.
 
@@ -47,15 +48,37 @@ Identifier forms:
     resourceLabelSingular = 'function';
     adminPath = '/data/:functions';
     commandName = 'functions';
+    inactiveApps = [];
     async run() {
         const { args, flags } = await this.parse(Functions);
         await this.runInspect({ args, flags });
     }
+    async getListResults(scope, flags) {
+        const [results, inactiveApps] = await Promise.all([
+            super.getListResults(scope, flags),
+            this.getInactiveApps(),
+        ]);
+        this.inactiveApps = inactiveApps;
+        return results;
+    }
     metaFor(r) {
         const parts = [];
-        if (!r.enabled) {
+        if (this.inactiveApps.some((app) => app.app_id === r.app_id)) {
+            parts.push('app inactive');
+        }
+        if (r.auto_disabled) {
+            parts.push('auto-disabled');
+        }
+        else if (!r.enabled) {
             parts.push('disabled');
         }
+        const failed = r.attempts_failed ?? 0;
+        if (failed > 0) {
+            const since = r.date_first_failed
+                ? `failing since ${r.date_first_failed} · `
+                : '';
+            parts.push(`${since}${failed} fail${failed === 1 ? '' : 's'}`);
+        }
         const trigger = deriveTrigger(r);
         if (trigger) {
             parts.push(trigger);
@@ -63,21 +86,60 @@ Identifier forms:
         if (r.date_cron_scheduled) {
             parts.push(`next ${r.date_cron_scheduled}`);
         }
-        if (r.date_final_attempt) {
-            parts.push(`last fail ${r.date_final_attempt}`);
+        const disableDate = failed > 0 && !r.auto_disabled && getDisableDate(r);
+        if (disableDate) {
+            parts.push(`may disable from ${disableDate}`);
         }
         return parts.length > 0 ? parts.join(' · ') : undefined;
     }
     filterListResults(results) {
         return results.filter((record) => record.kind !== 'workflow');
     }
-    emitDetail(record, flags) {
+    async emitDetail(record, flags) {
         if (record.kind === 'workflow') {
             const workflowName = record.name || record.id;
             const workflowRef = record.id || record.name;
             throw new Error(`Function '${workflowName}' is a workflow. Use "swell inspect workflows ${workflowRef}" instead.`);
         }
-        super.emitDetail(record, flags);
+        super.emitDetail(record, flags, flags.json ? [] : await this.detailNotes(record));
+    }
+    // Notes are best effort: a function shows without those it cannot read
+    async detailNotes(record) {
+        const notes = [];
+        const inactiveApps = await this.getInactiveApps().catch(() => []);
+        const inactiveApp = inactiveApps.find((app) => app.app_id === record.app_id);
+        if (inactiveApp) {
+            notes.push(`App ${slugFromInstalledApp(inactiveApp) ?? inactiveApp.app_id} is inactive: none of its functions run.`);
+        }
+        if (record.id &&
+            (record.auto_disabled || (record.attempts_failed ?? 0) > 0)) {
+            const failure = await this.lastFailedDelivery(record.id).catch(() => { });
+            if (failure) {
+                notes.push(`Last failed delivery: ${failure}`);
+            }
+        }
+        return notes;
+    }
+    async lastFailedDelivery(functionId) {
+        const response = await this.api.get({ adminPath: '/data/events:webhooks' }, { query: { function_id: functionId, sort: 'date_sent desc', limit: 1 } });
+        const delivery = response?.results?.[0];
+        if (!delivery) {
+            return undefined;
+        }
+        const { date_sent: dateSent, response: answer, status } = delivery;
+        if (status >= 200 && status < 300) {
+            return undefined;
+        }
+        const message = answer?.error?.message ??
+            answer?.message ??
+            (typeof answer === 'string' ? answer : undefined);
+        return [dateSent, status ?? 'no response', message]
+            .filter(Boolean)
+            .join(' · ');
+    }
+    async getInactiveApps() {
+        const response = await this.api.get({ adminPath: '/client/apps' });
+        return (response?.results ?? []).filter((app) => app.active === false);
     }
     /**
      * Model-triggered functions emit `/events:webhooks` rows on each invocation.
@@ -96,3 +158,24 @@ Identifier forms:
         return lines;
     }
 }
+// A function with a timeout over this is switched off sooner
+const LONG_TIMEOUT_MS = 10000;
+const LONG_TIMEOUT_DISABLE_DAYS = 2;
+/**
+ * When a failing function is switched off if it keeps failing: at its final
+ * attempt, or two days after its first failure when its timeout is long. A
+ * 404 switches it off at once.
+ * @param r The function
+ * @returns The date, as the API gives dates
+ */
+function getDisableDate(r) {
+    if ((r.timeout ?? 0) > LONG_TIMEOUT_MS) {
+        if (!r.date_first_failed) {
+            return undefined;
+        }
+        const date = new Date(r.date_first_failed);
+        date.setUTCDate(date.getUTCDate() + LONG_TIMEOUT_DISABLE_DAYS);
+        return date.toISOString();
+    }
+    return r.date_final_attempt;
+}

package/dist/commands/inspect/index.js

@@ -11,6 +11,8 @@ export default class Inspect extends Command {
         'swell inspect workflow-runs --workflow app.my-app.run-import --status active',
         'swell inspect notifications com.orders.receipt.v2',
         'swell inspect settings app.my-app',
+        'swell inspect components --app=.',
+        'swell inspect frontend app.my-app',
     ];
     async run() {
         this.log('Run "swell inspect --help" to see available subcommands.');

package/dist/inspect-resource-command.d.ts

@@ -87,7 +87,7 @@ export declare abstract class InspectResourceCommand extends SwellCommand {
      * `--json` is the machine-readable contract — hints belong in the same
      * stream as the human-facing output and are simply omitted there.
      */
-    protected emitDetail(record: any, flags: InspectResourceCommandParsed['flags']): void;
+    protected emitDetail(record: any, flags: InspectResourceCommandParsed['flags'], notes?: string[]): Promise<void> | void;
     private lookupByAppAndName;
     private printPreamble;
     protected throwNotFound(identifier: string): never;

package/dist/inspect-resource-command.js

@@ -189,7 +189,7 @@ export class InspectResourceCommand extends SwellCommand {
         if (!record) {
             this.throwNotFound(identifier);
         }
-        this.emitDetail(record, flags);
+        await this.emitDetail(record, flags);
     }
     /**
      * Per-subclass detail-mode hints. Return runnable commands pointing to
@@ -208,11 +208,17 @@ export class InspectResourceCommand extends SwellCommand {
      * `--json` is the machine-readable contract — hints belong in the same
      * stream as the human-facing output and are simply omitted there.
      */
-    emitDetail(record, flags) {
+    emitDetail(record, flags, notes = []) {
         this.log(JSON.stringify(record, null, 2));
         if (flags.json) {
             return;
         }
+        if (notes.length > 0) {
+            this.log();
+            for (const note of notes) {
+                this.log(note);
+            }
+        }
         const lines = this.hints(record);
         if (lines.length === 0) {
             return;

package/dist/lib/api-errors.d.ts

@@ -0,0 +1 @@
+export declare function errorReasons(errors: unknown, path?: string[]): string[];

package/dist/lib/api-errors.js

@@ -0,0 +1,28 @@
+// Every reason an API error answer gives, each with the path of the field it
+// is about: errors come as { field: { message } }, nested, as strings or as
+// { error } without a field
+export function errorReasons(errors, path = []) {
+    if (typeof errors === 'string') {
+        return [formatReason(path, errors)];
+    }
+    if (Array.isArray(errors)) {
+        return errors.flatMap((item) => errorReasons(item, path));
+    }
+    if (!errors || typeof errors !== 'object') {
+        return [];
+    }
+    const { message, ...fields } = errors;
+    if (typeof message === 'string') {
+        return [formatReason(path, message)];
+    }
+    return Object.entries(fields).flatMap(([key, value]) => 
+    // An error's code names its kind, not a reason
+    key === 'code' && typeof value === 'string'
+        ? []
+        : // Developers know an app's private_id as the id in swell.json
+            errorReasons(value, [...path, key === 'private_id' ? 'id' : key]));
+}
+function formatReason(path, message) {
+    const fieldPath = path.filter((key) => key !== 'error').join('.');
+    return fieldPath ? `${fieldPath}: ${message}` : message;
+}

package/dist/lib/apps/components.d.ts

@@ -8,6 +8,13 @@ export declare const COMPONENT_DEV_PATH = "/.swell/components/";
  * @returns {boolean} true for a root component
  */
 export declare function isRootComponentFile(file: string): boolean;
+/**
+ * Whether a component file has a name the platform cannot serve: component
+ * frames load by a name of letters, digits and dashes
+ * @param {string} file path relative to the app
+ * @returns {boolean} true for a root component that can never load
+ */
+export declare function isUnloadableComponentFile(file: string): boolean;
 /**
  * Component entries of an app
  * @param {string} appPath app directory

package/dist/lib/apps/components.js

@@ -16,6 +16,16 @@ export function isRootComponentFile(file) {
         parts[0] === 'components' &&
         COMPONENT_EXTENSIONS.has(path.extname(parts[1])));
 }
+/**
+ * Whether a component file has a name the platform cannot serve: component
+ * frames load by a name of letters, digits and dashes
+ * @param {string} file path relative to the app
+ * @returns {boolean} true for a root component that can never load
+ */
+export function isUnloadableComponentFile(file) {
+    return (isRootComponentFile(file) &&
+        !/^[\dA-Za-z-]+$/.test(getNameFromFilePath(file)));
+}
 /**
  * Component entries of an app
  * @param {string} appPath app directory

package/dist/lib/apps/extension-manifest.d.ts

@@ -0,0 +1 @@
+export declare function extensionManifestWarnings(extensions: unknown): string[];

package/dist/lib/apps/extension-manifest.js

@@ -0,0 +1,43 @@
+// The fields of an extension in swell.json that the platform reads: the
+// dashboard shows name, description and setting, and reads method (card or
+// another method) and subscriptions of a payment; it shows the icons, and the
+// logo of a card gateway. Checkout itself reads only the settings the
+// merchant activates.
+const READ_FIELDS = {
+    payment: [
+        'method',
+        'subscriptions',
+        'method_icon_src',
+        'gateway_icon_src',
+        'gateway_logo_src',
+    ],
+    shipping: ['carrier_icon_src'],
+    tax: [],
+};
+const COMMON_FIELDS = ['id', 'type', 'name', 'description', 'setting'];
+// Declared on the app model, but nothing reads them
+const UNREAD_FIELDS = new Set([
+    'gateway',
+    'carrier',
+    'method_logo_src',
+    'carrier_logo_src',
+]);
+export function extensionManifestWarnings(extensions) {
+    if (!Array.isArray(extensions)) {
+        return [];
+    }
+    return extensions.flatMap((extension) => {
+        if (!extension || typeof extension !== 'object') {
+            return [];
+        }
+        const read = new Set([
+            ...COMMON_FIELDS,
+            ...(READ_FIELDS[extension.type] ?? []),
+        ]);
+        return Object.keys(extension)
+            .filter((field) => !read.has(field))
+            .map((field) => UNREAD_FIELDS.has(field)
+            ? `swell.json extension "${extension.id}": ${field} has no effect`
+            : `swell.json extension "${extension.id}": unknown field ${field}`);
+    });
+}

package/dist/lib/apps/index.d.ts

@@ -206,6 +206,7 @@ export declare function hashFile(filePath: string, fileContents?: Buffer, relati
 export declare function hashString(...contents: (Buffer | string)[]): string;
 export declare function appAssetImage(appPath: string, fileName: string): Promise<string | undefined>;
 export declare function getNameFromFilePath(filePath: string): string;
+export declare function kebabCaseFilePath(filePath: string): string | undefined;
 export declare function appConfigFromFile(filePath: string, configType: ConfigType, appPath: string): Promise<AppConfig>;
 export declare function findAppConfig(app: App, filePath: string, configType: ConfigType): AppConfig | undefined;
 interface BatchAppFiles {

package/dist/lib/apps/index.js

@@ -364,6 +364,36 @@ export async function appAssetImage(appPath, fileName) {
 export function getNameFromFilePath(filePath) {
     return path.parse(filePath).name.replaceAll('_', '-');
 }
+// Configs in the root of these directories are named after their file
+const FILE_NAMED_CONFIG_DIRS = new Set([
+    AllConfigPaths.COMPONENT,
+    AllConfigPaths.CONTENT,
+    AllConfigPaths.FUNCTION,
+    AllConfigPaths.MODEL,
+    AllConfigPaths.NOTIFICATION,
+    AllConfigPaths.SETTING,
+    AllConfigPaths.WEBHOOK,
+]);
+// Among components, only .jsx and .tsx files are components; others are
+// modules the components import
+const COMPONENT_FILE_EXTENSIONS = new Set(['.jsx', '.tsx']);
+// The name of a config turns an underscore in its file name into a dash, so
+// the file goes by another name than what it deploys as unless renamed to this
+export function kebabCaseFilePath(filePath) {
+    const [dir, file, ...nested] = filePath.split('/');
+    if (nested.length > 0 ||
+        !FILE_NAMED_CONFIG_DIRS.has(dir) ||
+        !file?.includes('_') ||
+        (dir === AllConfigPaths.COMPONENT &&
+            !COMPONENT_FILE_EXTENSIONS.has(path.extname(file)))) {
+        return undefined;
+    }
+    const name = getNameFromFilePath(file);
+    if (name.startsWith('-')) {
+        return undefined;
+    }
+    return `${dir}/${name}${path.extname(file)}`;
+}
 export async function appConfigFromFile(filePath, configType, appPath) {
     const name = getNameFromFilePath(filePath);
     // Notification basenames must not contain dots: the inspect identifier

package/dist/lib/apps/paths.d.ts

@@ -1,5 +1,13 @@
 import { type GlobbyFilterFunction } from 'globby';
 import { ConfigType } from './index.js';
+export declare function isCredentialFile(relativePath: string): boolean;
+/**
+ * The .env files of the frontend that the push would have pushed, which its
+ * build reads: their change deploys the frontend again, though they stay local
+ * @param {string} appPath the app directory
+ * @returns {Promise<string[]>} paths relative to the app, sorted
+ */
+export declare function globFrontendEnvFiles(appPath: string): Promise<string[]>;
 export declare function toPosixPath(inputPath: string): string;
 export declare function globAllFilesByPath(appPath: string, dirPath?: string): Promise<string[]>;
 export declare function getGlobIgnorePathsChecker(appPath: string): Promise<GlobbyFilterFunction>;

package/dist/lib/apps/paths.js

@@ -2,6 +2,39 @@ import { globby, globbySync, isGitIgnored, } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { AllConfigPaths, ConfigType, StandardConfigPaths, StorefrontConfigPaths, ThemeConfigPaths, filePathExists, } from './index.js';
+// .env and .dev.vars files can hold real credentials: never pushed, whatever
+// the user's .gitignore says
+const CREDENTIAL_FILE_GLOBS = [
+    '**/.dev.vars',
+    '**/.dev.vars.*',
+    '**/.env',
+    '**/.env.*',
+];
+export function isCredentialFile(relativePath) {
+    const name = path.posix.basename(toPosixPath(relativePath));
+    return (name === '.env' ||
+        name.startsWith('.env.') ||
+        name === '.dev.vars' ||
+        name.startsWith('.dev.vars.'));
+}
+/**
+ * The .env files of the frontend that the push would have pushed, which its
+ * build reads: their change deploys the frontend again, though they stay local
+ * @param {string} appPath the app directory
+ * @returns {Promise<string[]>} paths relative to the app, sorted
+ */
+export async function globFrontendEnvFiles(appPath) {
+    const files = await globby([
+        `${AllConfigPaths.FRONTEND}/**/.env`,
+        `${AllConfigPaths.FRONTEND}/**/.env.*`,
+    ], {
+        cwd: appPath,
+        dot: true,
+        gitignore: true,
+        ignore: ['**/node_modules/**', '**/.wrangler/**'],
+    });
+    return files.sort();
+}
 function globOptions(appPath, options) {
     return {
         cwd: appPath,
@@ -9,8 +42,6 @@ function globOptions(appPath, options) {
         gitignore: true,
         ...options,
         expandDirectories: true,
-        // .dev.vars can hold real credentials — ignored here in case the
-        // user's .gitignore doesn't cover it.
         ignore: [
             '**/.swellrc',
             '**/.git/**',
@@ -21,8 +52,7 @@ function globOptions(appPath, options) {
             '**/bun.lockb',
             '**/bun.lock',
             '**/.wrangler/**',
-            '**/.dev.vars',
-            '**/.dev.vars.*',
+            ...CREDENTIAL_FILE_GLOBS,
             ...(options?.ignore || []),
         ],
     };

package/dist/lib/bundle.js

@@ -266,13 +266,26 @@ class SwellWorkflowRuntimeProxy {
     this.apiHost = getRuntimeApiHost(runtime);
   }
 
-  api(method, path, data) {
-    return this.request({
+  async api(method, path, data) {
+    const result = await this.request({
       type: 'api',
       method,
       path,
       data,
     });
+
+    // A write the API refuses answers with its errors. It fails as it does in
+    // functions, and is not retried, since the same write would fail again
+    if (method !== 'get' && result && result.errors) {
+      const error = new NonRetryableError(
+        method.toUpperCase() + ' ' + path + '\\n' + JSON.stringify(result.errors, null, 2),
+      );
+      error.status = 400;
+      error.body = result.errors;
+      throw error;
+    }
+
+    return result;
   }
 
   settings() {

package/dist/lib/create/function.d.ts

@@ -1,4 +1,4 @@
-export type FunctionType = 'cron' | 'model' | 'route' | 'workflow';
+export type FunctionType = 'action' | 'cron' | 'model' | 'route' | 'workflow';
 export type FunctionLanguage = 'js' | 'ts';
 export interface CreateFunctionArgs {
     functionName: string;

package/dist/lib/create/function.js

@@ -11,7 +11,7 @@ export function getFunctionTemplate({ description, events, extension, functionNa
         const eventsList = events
             .split(/\s*,\s*/g)
             .filter(Boolean)
-            .map((eventName) => `'${eventName}'`)
+            .map((eventName) => JSON.stringify(eventName))
             .join(', ');
         typeAppend = `,
   model: {
@@ -28,15 +28,19 @@ export function getFunctionTemplate({ description, events, extension, functionNa
     if (trigger === 'cron') {
         typeAppend = `,
   cron: {
-    schedule: '${schedule}',
+    schedule: ${JSON.stringify(schedule)},
   },`;
+    }
+    if (trigger === 'action') {
+        typeAppend = `,
+  action: true,`;
     }
     let extensionAppend = '';
     if (extension) {
-        extensionAppend = `extension: '${extension}',\n  `;
+        extensionAppend = `extension: ${JSON.stringify(extension)},\n  `;
     }
     return `export const config${language === 'ts' ? ': SwellConfig' : ''} = {
-  ${extensionAppend}description: '${description}'${typeAppend}
+  ${extensionAppend}description: ${JSON.stringify(description)}${typeAppend}
 };
 
 export default async function (req${language === 'ts' ? ': SwellRequest' : ''}) {
@@ -50,7 +54,7 @@ function getWorkflowTemplate({ description, functionName, language, }) {
     const stepParam = language === 'ts' ? 'step: SwellWorkflowStep' : 'step';
     return `export const config = {
   kind: 'workflow',
-  description: '${description}'
+  description: ${JSON.stringify(description)}
 };
 
 export default class ${className} {

package/dist/lib/create/index.js

@@ -15,8 +15,9 @@ export const toAppId = (value) => String(value || '')
     .replaceAll(/([a-z])([A-Z])/g, '$1_$2')
     .toLowerCase();
 // Example: 'My Thing' => 'my-thing'
+// And: 'sync_order' => 'sync-order', the name a function deploys under
 // And: 'myThing' => 'myThing'
-export const toFunctionFileName = (value) => value.split('.')[0].replace(' ', '-');
+export const toFunctionFileName = (value) => value.split('.')[0].replaceAll(/[\s_]+/g, '-');
 // Example: 'My Thing' => 'my-things'
 export const toCollectionName = (value) => pluralize(value.replaceAll(/[^A-Za-z]/g, '-').replace(' ', '')).toLowerCase();
 // Example: 'my-things' => 'My Things'

package/dist/lib/create/model.d.ts

@@ -13,11 +13,15 @@ interface ModelEvent {
     id: ModelEventID;
 }
 type ModelEventID = 'created' | 'deleted' | 'updated';
-type ModelFieldResponse = Record<string, ModelFieldTypeObject>;
-type FieldType = 'collection' | 'currency' | 'image' | 'int' | 'link' | 'string';
-interface ModelFieldTypeObject {
+type ModelFieldResponse = Record<string, ModelField>;
+export declare const FIELD_TYPES: readonly ["string", "int", "float", "bool", "date", "currency", "objectid", "array", "object", "collection", "link", "file", "filedata"];
+type FieldType = (typeof FIELD_TYPES)[number];
+interface ModelField {
+    model?: string;
     type: FieldType;
+    value_type?: string;
 }
+export declare function fieldPairProblem(pair: string): string | undefined;
 export declare function parseFields(fields: string[]): ModelFieldResponse;
 export declare function parseEvents(events: string[]): ModelEventObject;
 export {};

package/dist/lib/create/model.js

@@ -1,14 +1,72 @@
-export function parseFields(fields) {
-    if (fields.length === 0) {
-        return {};
+// The field types of the model schema, https://json.swell.store/model.json
+export const FIELD_TYPES = [
+    'string',
+    'int',
+    'float',
+    'bool',
+    'date',
+    'currency',
+    'objectid',
+    'array',
+    'object',
+    'collection',
+    'link',
+    'file',
+    'filedata',
+];
+// Items of an array given as a flag; object and link items need more than a type
+const ARRAY_VALUE_TYPES = [
+    'string',
+    'int',
+    'float',
+    'bool',
+    'date',
+    'currency',
+    'objectid',
+    'file',
+    'filedata',
+];
+function splitFieldPair(pair) {
+    return pair.split(':').map((part) => part.trim());
+}
+// Why a field given as id:type, id:link:<model> or id:array:<type> cannot be
+// written, if it cannot
+export function fieldPairProblem(pair) {
+    const [id, type, target] = splitFieldPair(pair);
+    if (!id || !type) {
+        return `${pair}: expected id:type`;
+    }
+    if (type === 'image') {
+        return `${pair}: Invalid field type 'image'; use file`;
+    }
+    if (type === 'collection') {
+        return `${pair}: A collection needs its fields; add it with them to the model file`;
+    }
+    if (!FIELD_TYPES.includes(type)) {
+        return `${pair}: unknown type '${type}'`;
+    }
+    if (type === 'link' && !target) {
+        return `${pair}: a link needs the model it links to, e.g. ${id}:link:accounts`;
     }
+    if (type === 'array' && target && !ARRAY_VALUE_TYPES.includes(target)) {
+        return `${pair}: an array given here holds ${ARRAY_VALUE_TYPES.join(', ')}`;
+    }
+    if (target && type !== 'link' && type !== 'array') {
+        return `${pair}: only link and array take a third part`;
+    }
+}
+export function parseFields(fields) {
     const fieldResponse = {};
-    for (const fieldPair of fields) {
-        if (fieldPair.includes(':')) {
-            const [id, type] = fieldPair.split(':');
-            fieldResponse[id] = {
-                type,
-            };
+    for (const pair of fields) {
+        const [id, type, target] = splitFieldPair(pair);
+        if (type === 'link') {
+            fieldResponse[id] = { type, model: target };
+        }
+        else if (type === 'array') {
+            fieldResponse[id] = { type, value_type: target || 'string' };
+        }
+        else {
+            fieldResponse[id] = { type };
         }
     }
     return fieldResponse;

package/dist/lib/inspect/extensions.d.ts

@@ -24,7 +24,7 @@ export interface ManifestEntry {
 }
 /** CLI-resolved type. Diverges from raw manifest `type` for payment (card vs alt). */
 export type ExtensionType = 'card' | 'alt' | 'shipping' | 'tax';
-export type ExtensionStatus = 'not deployed' | 'not activated' | 'app id mismatch' | 'id mismatch' | 'not selected' | 'gateway missing' | 'not enabled' | 'no handler' | 'handler mismatch' | 'activated';
+export type ExtensionStatus = 'not deployed' | 'settings unavailable' | 'not activated' | 'app id mismatch' | 'id mismatch' | 'not selected' | 'gateway missing' | 'not enabled' | 'no handler' | 'handler mismatch' | 'activated';
 export type ActionOwner = 'dev' | 'merchant' | null;
 export interface FunctionRecord {
     id?: string;
@@ -163,8 +163,6 @@ export declare function formatExtensionKey(slug: string, extId: string): string;
  * resolves to `card` even with no explicit `method`.
  */
 export declare function resolveExtensionType(entry: Pick<ManifestEntry, 'type' | 'method' | 'id'>): ExtensionType;
-/** Apply the platform's `if(method, method, id)` formula. */
-export declare function paymentMethodIdFor(entry: Pick<ManifestEntry, 'method' | 'id'>): string;
 /** Shipping records use `app_<appId>_<extId>` as both the row id and the carrier id. */
 export declare function shippingBindId(appId: string, extId: string): string;
 /** Card-gateway records use the same id form as shipping rows. */
@@ -229,12 +227,15 @@ export interface BuildDetailInput {
     payments?: PaymentSettings | null;
     shipments?: ShippingSettings | null;
     taxes?: TaxSettingsRecord | null;
+    /** Why each settings record could not be read, if it could not. */
+    unavailableSettings?: UnavailableSettings;
     /** Functions in the same app whose top-level `extension` matches this extId. */
     functions: FunctionRecord[];
     /** Components in the same app whose `values.extension` matches this extId. */
     components: ComponentRecord[];
     localDiff?: LocalDiff | null;
 }
+export type UnavailableSettings = Partial<Record<'payments' | 'shipments' | 'taxes', string>>;
 export interface BuildOrphanInput {
     appId: string;
     appSlug: string;