@swell/cli 2.9.31 → 2.9.33

package/dist/lib/apps/actions.js

@@ -0,0 +1,114 @@
+function isFunctionAction(item) {
+    return (typeof item?.id === 'string' &&
+        typeof item?.function === 'string');
+}
+// The dashboard renders the fields of rows and groups in place
+function flattenFields(fields) {
+    if (!Array.isArray(fields)) {
+        return [];
+    }
+    return fields.flatMap((field) => field?.type === 'field_row' || field?.type === 'field_group'
+        ? flattenFields(field.fields)
+        : [field]);
+}
+function getActionFields(fields) {
+    return flattenFields(fields).filter((field) => field?.type === 'action');
+}
+/**
+ * The function actions a content config declares.
+ *
+ * @param values the values of the content config
+ * @returns the actions
+ */
+export function getContentActions(values) {
+    const views = Array.isArray(values?.views) ? values.views : [];
+    const actions = [];
+    for (const view of views) {
+        const source = view.type || (view.id === 'list' ? 'list' : 'record');
+        for (const action of [
+            ...(view.actions || []),
+            ...(view.extra_actions || []),
+        ]) {
+            if (isFunctionAction(action)) {
+                actions.push({ ...pickAction(action), source, view: view.id });
+            }
+        }
+        for (const action of view.bulk_actions || []) {
+            if (isFunctionAction(action)) {
+                actions.push({
+                    ...pickAction(action),
+                    ...(view.query ? { query: view.query } : undefined),
+                    source: 'bulk',
+                    view: view.id,
+                });
+            }
+        }
+    }
+    const fields = [
+        ...(values?.fields || []),
+        ...views.flatMap((view) => [
+            ...(view.fields || []),
+            ...(view.tabs || []).flatMap((tab) => tab?.fields || []),
+        ]),
+    ];
+    for (const field of getActionFields(fields)) {
+        if (isFunctionAction(field)) {
+            actions.push({ ...pickAction(field), source: 'field' });
+        }
+    }
+    return actions;
+}
+/**
+ * The function actions a settings config declares.
+ *
+ * @param values the values of the settings config
+ * @param settings the name of the settings config
+ * @returns the actions
+ */
+export function getSettingsActions(values, settings) {
+    const actions = [];
+    for (const action of values?.actions || []) {
+        if (isFunctionAction(action)) {
+            actions.push({ ...pickAction(action), settings, source: 'settings' });
+        }
+    }
+    for (const field of getActionFields(values?.fields)) {
+        if (isFunctionAction(field)) {
+            actions.push({ ...pickAction(field), settings, source: 'field' });
+        }
+    }
+    return actions;
+}
+/**
+ * The ids of the fields of an action's modal, as the platform finds them to
+ * pass on only their values.
+ *
+ * @param modal the modal of the action
+ * @returns the field ids
+ */
+export function getModalFieldIds(modal) {
+    return flattenFields(modal.fields)
+        .map((field) => field?.id)
+        .filter((id) => typeof id === 'string');
+}
+/**
+ * A function name as the platform compares an action's `function` with it.
+ *
+ * @param name a function name
+ * @returns the name in the form the platform compares
+ */
+export function functionSlug(name) {
+    return name
+        .replaceAll(/[^\s\w./:-]/g, '')
+        .replaceAll(/[\s./:_-]+/g, '-')
+        .replaceAll(/^-+|-+$/g, '')
+        .replaceAll(/([a-z])([A-Z])/g, '$1-$2')
+        .toLowerCase();
+}
+function pickAction(action) {
+    return {
+        function: action.function,
+        id: action.id,
+        ...(action.modal ? { modal: action.modal } : undefined),
+    };
+}

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/listing.d.ts

@@ -0,0 +1 @@
+export declare function warnListingSources(appPath: string, config: Record<string, any>, warn: (message: string) => void): void;

package/dist/lib/apps/listing.js

@@ -0,0 +1,41 @@
+import { statSync } from 'node:fs';
+import * as path from 'node:path';
+const LISTING_SOURCE_FIELDS = ['logo_src', 'preview_src', 'preview_mobile_src'];
+const LISTING_SOURCE_LISTS = ['images', 'highlights'];
+// The listing takes its full description from DESCRIPTION.md and each image
+// from the asset whose path from the app root is the swell.json value as
+// written, so values that point elsewhere do nothing. The platform takes an
+// empty value as unset.
+export function warnListingSources(appPath, config, warn) {
+    if (config.full_description !== undefined) {
+        warn('swell.json sets full_description, which push does not apply: the full description is the content of DESCRIPTION.md at the app root.');
+    }
+    const sources = [
+        ...LISTING_SOURCE_FIELDS.map((field) => [
+            field,
+            config[field],
+        ]),
+        ...LISTING_SOURCE_LISTS.flatMap((list) => (Array.isArray(config[list]) ? config[list] : []).map((item, index) => [
+            `${list}[${index}].image_src`,
+            item?.image_src,
+        ])),
+    ];
+    for (const [field, source] of sources) {
+        if (typeof source !== 'string' || source === '') {
+            continue;
+        }
+        const filePath = path.posix.normalize(source.replaceAll('\\', '/'));
+        const stats = statSync(path.join(appPath, filePath), {
+            throwIfNoEntry: false,
+        });
+        if (!stats?.isFile()) {
+            warn(`swell.json ${field} names ${source}, which the app does not have: the listing gets no image from it.`);
+        }
+        else if (!filePath.startsWith('assets/')) {
+            warn(`swell.json ${field} names ${source}, which is not in assets/: the listing gets no image from it. Move the file to assets/ and write assets/${path.posix.basename(filePath)}.`);
+        }
+        else if (filePath !== source) {
+            warn(`swell.json ${field} names ${source}, which is not the file's path from the app root: the listing gets no image from it. Write ${filePath}.`);
+        }
+    }
+}

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

@@ -60,7 +60,7 @@ export async function bundleFunction(filePath) {
 }
 export async function bundleWorkflow(filePath, analysis) {
     try {
-        const entrySource = getSwellWorkflowEntrypoint(filePath);
+        const entrySource = await getSwellWorkflowEntrypoint(filePath);
         const buildResult = await esbuild.build({
             bundle: true,
             stdin: {
@@ -130,13 +130,22 @@ async function getSwellFunctionWrapper() {
     const __dirname = path.dirname(__filename);
     return fs.readFile(path.join(__dirname, './swell-function-wrapper.js'), 'utf8');
 }
-function getSwellWorkflowEntrypoint(filePath) {
+// The entry defines these functions itself, so the bundle names no file of
+// the CLI and the workflow module exports only its entrypoint
+async function getSwellWorkflowRequest() {
+    const source = await fs.readFile(path.join(path.dirname(fileURLToPath(import.meta.url)), './swell-workflow-request.js'), 'utf8');
+    return source.replaceAll(/^export /gm, '');
+}
+async function getSwellWorkflowEntrypoint(filePath) {
     const workflowImport = `./${path.basename(filePath)}`;
+    const workflowRequest = await getSwellWorkflowRequest();
     return `
 import { WorkflowEntrypoint } from 'cloudflare:workers';
 import { NonRetryableError } from 'cloudflare:workflows';
 import UserWorkflow from ${JSON.stringify(workflowImport)};
 
+${workflowRequest}
+
 const RUNTIME_PROXY_PATH = '/:workflows/runtime/request';
 const RUNTIME_TOKEN_PATTERN = /\\bwf_rt_[0-9A-Za-z]+_[0-9A-Za-z]{12,}\\b/g;
 
@@ -210,38 +219,6 @@ function getInvocation(event) {
   return payload;
 }
 
-function buildWorkflowRequest(invocation, proxy) {
-  const runtime = invocation.runtime;
-
-  return {
-    id: runtime.request_id,
-    appId: runtime.app_slug || runtime.app_id,
-    environmentId: runtimeEnvironmentId(runtime),
-    store: {
-      id: runtime.store_id,
-    },
-    app: {
-      admin_url: runtime.app_admin_url,
-    },
-    data: invocation.data,
-    workflow: {
-      workflow_id: runtime.workflow_id,
-      workflow_name: runtime.workflow_name,
-      workflow_instance_id: runtime.workflow_instance_id,
-      trigger: runtime.trigger,
-      request_id: runtime.request_id,
-    },
-    isLocalDev: false,
-    swell: {
-      get: (path, data) => proxy.api('get', path, data),
-      post: (path, data) => proxy.api('post', path, data),
-      put: (path, data) => proxy.api('put', path, data),
-      delete: (path, data) => proxy.api('delete', path, data),
-      settings: () => proxy.settings(),
-    },
-  };
-}
-
 function buildWorkflowStep(cloudflareStep, proxy) {
   return Object.freeze({
     do(name, optionsOrCallback, maybeCallback) {
@@ -289,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() {
@@ -361,11 +351,6 @@ function getRuntimeApiHost(runtime) {
   return apiHost.replace(/\\/$/, '');
 }
 
-// 'test' in the test environment, null in live
-function runtimeEnvironmentId(runtime) {
-  return runtime.environment_id || null;
-}
-
 function runtimeIdentity(runtime) {
   return {
     app_id: runtime.app_id,

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/function-declarations.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The types an app's functions type-check against: the app's own
+ * @swell/app-types when it has the package, otherwise the CLI's.
+ *
+ * @param directory a directory of the app
+ * @returns the declarations, after a line naming the package version
+ */
+export declare function getFunctionDeclarations(directory: string): Promise<string>;

package/dist/lib/function-declarations.js

@@ -0,0 +1,27 @@
+import * as fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+/**
+ * The types an app's functions type-check against: the app's own
+ * @swell/app-types when it has the package, otherwise the CLI's.
+ *
+ * @param directory a directory of the app
+ * @returns the declarations, after a line naming the package version
+ */
+export async function getFunctionDeclarations(directory) {
+    const file = resolveAppTypes(path.join(directory, 'package.json')) ??
+        resolveAppTypes(import.meta.url);
+    if (!file) {
+        throw new Error('@swell/app-types is not installed');
+    }
+    const { version } = JSON.parse(await fs.readFile(path.join(path.dirname(file), 'package.json'), 'utf8'));
+    return `// @swell/app-types ${version}\n${await fs.readFile(file, 'utf8')}`;
+}
+function resolveAppTypes(from) {
+    try {
+        return createRequire(from).resolve('@swell/app-types/index.d.ts');
+    }
+    catch {
+        return undefined;
+    }
+}