@swell/cli 2.9.21 → 2.9.22

package/dist/commands/app/push.d.ts

@@ -28,4 +28,5 @@ export default class AppPush extends PushAppCommand {
      */
     confirmPushConflicts(conflictsFlag?: string, file?: string): Promise<boolean>;
     run(): Promise<void>;
+    private exitIfFilesFailed;
 }

package/dist/commands/app/push.js

@@ -153,6 +153,7 @@ ${Object.values(AllConfigPaths)
                 }
                 this.log();
                 this.logDashboardUrl(flags);
+                this.exitIfFilesFailed();
                 return;
             }
         }
@@ -162,5 +163,12 @@ ${Object.values(AllConfigPaths)
             this.log();
         }
         this.logDashboardUrl(flags);
+        this.exitIfFilesFailed();
+    }
+    // A skipped file is a failed push, for scripts and CI too
+    exitIfFilesFailed() {
+        if (this.failedFiles.length > 0) {
+            this.error(`${this.failedFiles.length} file(s) failed to push: ${this.failedFiles.join(', ')}`);
+        }
     }
 }

package/dist/lib/apps/app-config.d.ts

@@ -45,6 +45,16 @@ export declare abstract class AppConfig {
     version?: string;
     constructor(attrs?: Partial<AppConfig>);
     load(): Promise<void>;
+    /**
+     * The hash push compares with the pushed config to skip unchanged files
+     * @returns {Promise<string | undefined>} the hash
+     */
+    protected contentHash(): Promise<string | undefined>;
+    /**
+     * Full path of the app directory this config belongs to
+     * @returns {string} the path
+     */
+    protected appRoot(): string;
     static create(attrs?: Partial<AppConfig>): Promise<AppConfig>;
     isRootConfig(configDir: string): boolean;
     postData(): Promise<any>;
@@ -88,6 +98,7 @@ export declare class AppConfigFunction extends AppConfig {
     hasValues: boolean;
     type: ConfigType;
     isRootFunction(): boolean;
+    protected contentHash(): Promise<string | undefined>;
     preparePostData(postData: any): Promise<any>;
 }
 export declare class AppConfigComponent extends AppConfig {

package/dist/lib/apps/app-config.js

@@ -3,9 +3,9 @@ import isEmpty from 'lodash/isEmpty.js';
 import { detectFilenameMime } from 'mime-detect';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { bundleFunction, bundleComponent, bundleWorkflow } from '../bundle.js';
+import { bundleFunction, bundleComponent, bundleWorkflow, getLocalInputs, } from '../bundle.js';
 import { analyzeFunctionSource, hasKindDiagnostic, workflowStaticConfigError, } from '../function-source-analysis.js';
-import { AllConfigPaths, ConfigType, filePathExistsAsync, hashFile, } from './index.js';
+import { AllConfigPaths, ConfigType, filePathExistsAsync, hashFile, hashString, } from './index.js';
 export class IgnoringFileError extends Error {
     constructor(message) {
         super(message);
@@ -83,11 +83,25 @@ export class AppConfig {
         if (await filePathExistsAsync(this.appPath)) {
             this.fileData = await fs.readFile(this.appPath);
             this.fileHash = hashFile(this.appPath, this.fileData, this.filePath);
-            this.hash = this.hash || this.fileHash;
+            this.hash = this.hash || (await this.contentHash());
             this.byteSize = this.fileData.length;
             this.mbSize = this.byteSize / 1024 / 1024;
         }
     }
+    /**
+     * The hash push compares with the pushed config to skip unchanged files
+     * @returns {Promise<string | undefined>} the hash
+     */
+    async contentHash() {
+        return this.fileHash;
+    }
+    /**
+     * Full path of the app directory this config belongs to
+     * @returns {string} the path
+     */
+    appRoot() {
+        return path.resolve(this.appPath, ...this.filePath.split('/').map(() => '..'));
+    }
     static async create(attrs = {}) {
         let instance;
         switch (attrs.type) {
@@ -263,6 +277,27 @@ export class AppConfigFunction extends AppConfig {
         return (this.isRootConfig('functions') &&
             (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts')));
     }
+    // A function deploys as a bundle, so the hash includes the local files it
+    // imports: a change in shared code under functions/lib redeploys it
+    async contentHash() {
+        if (!this.isRootFunction() || !this.fileHash) {
+            return this.fileHash;
+        }
+        const appRoot = this.appRoot();
+        let inputs;
+        try {
+            inputs = await getLocalInputs(this.appPath, appRoot);
+        }
+        catch {
+            // Unknown until it compiles: push tries it and reports the error
+            return undefined;
+        }
+        const imports = inputs
+            .filter((input) => input !== this.filePath)
+            .sort()
+            .map((input) => hashFile(path.join(appRoot, input), undefined, input));
+        return hashString(this.fileHash, ...imports);
+    }
     async preparePostData(postData) {
         if (this.isRootFunction()) {
             try {

package/dist/lib/apps/frontend-package.js

@@ -3,7 +3,7 @@ import { execa } from 'execa';
 import { isIgnoredByIgnoreFiles } from 'globby';
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
+import { createRequire, isBuiltin } from 'node:module';
 import * as os from 'node:os';
 import * as path from 'node:path';
 const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
@@ -155,13 +155,25 @@ export async function checkModuleGraph(pkg) {
                 name: 'retained-frontend-modules',
                 setup(builder) {
                     builder.onResolve({ filter: /.*/ }, (args) => {
-                        if (/^(?:node|cloudflare):/.test(args.path))
+                        // The provider validates runtime module names at upload, so a
+                        // scheme is never checked against the Node version running here.
+                        if (args.kind !== 'entry-point' &&
+                            (/^(?:node|cloudflare):/.test(args.path) || isBuiltin(args.path)))
                             return { path: args.path, external: true };
+                        // Like the runtime, resolve any other name, bare or relative,
+                        // against the importer's directory.
                         const name = args.kind === 'entry-point'
                             ? args.path
                             : path.posix.join(path.posix.dirname(args.importer), args.path);
-                        if (!modules.has(name))
-                            throw new Error(`Missing frontend Worker module: ${name}`);
+                        if (!modules.has(name)) {
+                            const from = args.importer
+                                ? ` (imported as "${args.path}" from "${args.importer}")`
+                                : '';
+                            const hint = args.importer && /^[\w@]/.test(args.path)
+                                ? '. npm dependencies must be bundled.'
+                                : '';
+                            throw new Error(`Missing frontend Worker module: ${name}${from}${hint}`);
+                        }
                         return { path: name, namespace: 'frontend' };
                     });
                     builder.onLoad({ filter: /.*/, namespace: 'frontend' }, (args) => {

package/dist/lib/bundle.d.ts

@@ -1,4 +1,12 @@
 import type { FunctionSourceAnalysis } from './function-source-analysis.js';
+/**
+ * Local source files an entry point imports, itself included, relative to
+ * rootDir. Packages are not followed: only the app's own files are listed.
+ * @param {string} entryPoint path of the entry point, relative to rootDir
+ * @param {string} rootDir directory the paths are relative to
+ * @returns {Promise<string[]>} paths of the imported files
+ */
+export declare function getLocalInputs(entryPoint: string, rootDir: string): Promise<string[]>;
 export declare function bundleFunction(filePath: string): Promise<any>;
 export declare function bundleWorkflow(filePath: string, analysis: FunctionSourceAnalysis): Promise<any>;
 export declare function bundleComponent(filePath: string): Promise<any>;

package/dist/lib/bundle.js

@@ -2,6 +2,27 @@ import * as esbuild from 'esbuild';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
+/**
+ * Local source files an entry point imports, itself included, relative to
+ * rootDir. Packages are not followed: only the app's own files are listed.
+ * @param {string} entryPoint path of the entry point, relative to rootDir
+ * @param {string} rootDir directory the paths are relative to
+ * @returns {Promise<string[]>} paths of the imported files
+ */
+export async function getLocalInputs(entryPoint, rootDir) {
+    const { metafile } = await esbuild.build({
+        absWorkingDir: rootDir,
+        bundle: true,
+        entryPoints: [entryPoint],
+        external: ['cloudflare:*'],
+        logLevel: 'silent',
+        metafile: true,
+        packages: 'external',
+        platform: 'node',
+        write: false,
+    });
+    return Object.keys(metafile.inputs);
+}
 export async function bundleFunction(filePath) {
     try {
         const buildResult = await esbuild.build({

package/dist/lib/create/tests/templates/mock-request.js

@@ -46,6 +46,7 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
   } = options;
 
   const requestHeaders = new Headers(headers);
+  const requestQuery = { ...Object.fromEntries(new URL(url).searchParams), ...query };
   const originalRequest = new Request(url, {
     method,
     headers: requestHeaders,
@@ -88,40 +89,20 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
     apiHost: env.SWELL_API_BASE_URL || "",
     logParams: undefined,
     swell: swellClient as SwellAPI,
-    body: data,
-    data,
-    query,
+    rawBody: method === "GET" ? "" : JSON.stringify(data),
+    body: method === "GET" ? "" : { ...data },
+    data: { ...(method === "GET" ? {} : data), ...requestQuery },
+    query: requestQuery,
     initialize: async () => {},
-    parseJson: (input: string) => JSON.parse(input),
+    parseJson: (input: string) => {
+      try { return JSON.parse(input); } catch { return {}; }
+    },
     reject: (
       code: string,
       message: string,
       options: { status?: number } = {}
     ) => {
-      const status =
-        typeof options.status === "number" &&
-        options.status >= 400 &&
-        options.status < 500
-          ? options.status
-          : 422;
-      const error = new Error(
-        message || "Request rejected by function"
-      ) as Error & {
-        body: { $reject: { code: string; message: string; status: number } };
-        code: string;
-        status: number;
-      };
-      error.name = "SwellRejection";
-      error.code = code;
-      error.status = status;
-      error.body = {
-        $reject: {
-          code,
-          message: error.message,
-          status,
-        },
-      };
-      return error;
+      return new SwellRejection(code, message, options);
     },
     appValues: (idOrValues: string | SwellData, values?: SwellData) => {
       const targetAppId =

package/dist/lib/create/tests/templates/setup-globals.js

@@ -1,21 +1,6 @@
 export function setupGlobalsTemplate() {
     return `\
-class SwellErrorImpl extends Error {
-  status: number;
-  body?: unknown;
-
-  constructor(message: string | object, options: { status?: number } = {}) {
-    const text =
-      typeof message === "string"
-        ? message
-        : JSON.stringify(message, null, 2);
-
-    super(text);
-    this.name = "SwellError";
-    this.status = options.status ?? 500;
-    this.body = typeof message === "string" ? undefined : message;
-  }
-}
+import { SwellError } from "@swell/apps-sdk";
 
 class SwellRejectionImpl extends Error {
   status: number;
@@ -51,7 +36,7 @@ class SwellRejectionImpl extends Error {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-(globalThis as any).SwellError = SwellErrorImpl;
+(globalThis as any).SwellError = SwellError;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 (globalThis as any).SwellRejection = SwellRejectionImpl;
 

package/dist/lib/create/tests/templates/unit-test.js

@@ -14,7 +14,7 @@ describe("Unit test examples", () => {
     });
 
     expect(req.data.product_id).toBe("prod_123");
-    expect(req.session.account_id).toBe("acc_456");
+    expect(req.session?.account_id).toBe("acc_456");
   });
 
   it("mocks swell.get", async () => {

package/dist/lib/create/tests.js

@@ -7,6 +7,7 @@ const TEST_DEV_DEPENDENCIES = {
     '@cloudflare/vitest-pool-workers': '0.12.x',
     vitest: '3.2.x',
     '@swell/app-types': 'latest',
+    '@swell/apps-sdk': '2.0.0-alpha.0',
 };
 async function writeTextFile(filePath, contents, overwrite) {
     if (!overwrite && (await filePathExistsAsync(filePath))) {
@@ -52,6 +53,9 @@ async function updatePackageJson(appPath) {
     if (!devDeps['@swell/app-types'] && !deps['@swell/app-types']) {
         devDeps['@swell/app-types'] = TEST_DEV_DEPENDENCIES['@swell/app-types'];
     }
+    if (!devDeps['@swell/apps-sdk'] && !deps['@swell/apps-sdk']) {
+        devDeps['@swell/apps-sdk'] = TEST_DEV_DEPENDENCIES['@swell/apps-sdk'];
+    }
     pkg.devDependencies = devDeps;
     const scripts = (pkg.scripts || {});
     scripts.test = scripts.test || 'vitest run';

package/dist/push-app-command.d.ts

@@ -48,6 +48,13 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     }, shouldChoose?: boolean): Promise<App | undefined>;
     getExistingApp(appId: string): Promise<App>;
     getFrontendDeploymentHash(): Promise<string | undefined>;
+    /**
+     * Files outside frontend/ that the worker's entry point imports, relative to
+     * the app path. Only a local entry point set by `main` in the wrangler
+     * config is followed; frameworks that build their own entry are not.
+     * @returns {Promise<string[]>} paths of the imported files
+     */
+    getFrontendSharedInputs(): Promise<string[]>;
     getFrontendProjectType(required?: boolean): Promise<FrontendProjectType | null>;
     getStorefrontToPull(args?: {
         appId?: string;

package/dist/push-app-command.js

@@ -8,9 +8,10 @@ import ora from 'ora';
 import { default as swellConfig } from './lib/app-config.js';
 import { buildFrontendPackage, getManagedFrontendFramework, } from './lib/apps/frontend-package.js';
 import { warnFrontendRouteCollisions } from './lib/apps/frontend-routes.js';
-import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, CUSTOM_FRAMEWORK_SLUG, appConfigFromFile, filePathExistsAsync, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getProjectCommands, globAllFilesByPath, hashString, isPathDirectory, toPosixPath, } from './lib/apps/index.js';
+import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, CUSTOM_FRAMEWORK_SLUG, appConfigFromFile, filePathExistsAsync, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getProjectCommands, globAllFilesByPath, hashFile, hashString, isPathDirectory, toPosixPath, } from './lib/apps/index.js';
 import { getGlobIgnorePathsChecker } from './lib/apps/paths.js';
 import { slugFromApp } from './lib/apps/slug.js';
+import { getLocalInputs } from './lib/bundle.js';
 import { default as localConfig } from './lib/config.js';
 import { toAppId } from './lib/create/index.js';
 import { detectPackageManager, transformCommand, } from './lib/package-manager.js';
@@ -21,6 +22,27 @@ import { RemoteAppCommand } from './remote-app-command.js';
 const PUSH_CONCURRENCY = 3;
 const WATCH_WINDOW_MS = 100;
 const DEV_SERVER_FALLBACK_PORT = 3000;
+const WRANGLER_CONFIG_FILES = [
+    'wrangler.jsonc',
+    'wrangler.json',
+    'wrangler.toml',
+];
+/**
+ * The `main` entry point of a wrangler config (JSON, JSONC or TOML)
+ * @param {string} frontendPath directory of the wrangler config
+ * @returns {string | undefined} the entry point, relative to frontendPath
+ */
+function readWranglerMain(frontendPath) {
+    for (const name of WRANGLER_CONFIG_FILES) {
+        const configPath = path.join(frontendPath, name);
+        if (fs.existsSync(configPath)) {
+            // "main": "src/index.ts" in JSON, main = "src/index.ts" in TOML
+            return fs
+                .readFileSync(configPath, 'utf8')
+                .match(/^\s*"?main"?\s*[:=]\s*"([^"]+)"/m)?.[1];
+        }
+    }
+}
 export class PushAppCommand extends RemoteAppCommand {
     frontendPath = '';
     hasLoggedLocalPreviewUrl = false;
@@ -466,9 +488,34 @@ export class PushAppCommand extends RemoteAppCommand {
         if (frontendHashes.length > 0) {
             const packageHash = localConfigs.find((config) => config.filePath === 'package.json')?.hash;
             frontendHashes += `|${packageHash}`;
+            // Shared code the worker imports from outside frontend/, e.g. functions/lib
+            for (const input of await this.getFrontendSharedInputs()) {
+                frontendHashes += `|${hashFile(path.join(this.appPath, input), undefined, input)}`;
+            }
         }
         return frontendHashes.length > 0 ? hashString(frontendHashes) : undefined;
     }
+    /**
+     * Files outside frontend/ that the worker's entry point imports, relative to
+     * the app path. Only a local entry point set by `main` in the wrangler
+     * config is followed; frameworks that build their own entry are not.
+     * @returns {Promise<string[]>} paths of the imported files
+     */
+    async getFrontendSharedInputs() {
+        const main = readWranglerMain(path.join(this.appPath, 'frontend'));
+        const entry = main && toPosixPath(path.join('frontend', main));
+        if (!entry || !fs.existsSync(path.join(this.appPath, entry))) {
+            return [];
+        }
+        try {
+            const inputs = await getLocalInputs(entry, this.appPath);
+            return inputs.filter((input) => !input.startsWith('frontend/')).sort();
+        }
+        catch {
+            // Build errors surface when wrangler deploys the worker
+            return [];
+        }
+    }
     async getFrontendProjectType(required = true) {
         this.frontendPath = path.join(this.appPath, 'frontend');
         const frontendExists = await filePathExistsAsync(this.frontendPath);

package/dist/remote-app-command.d.ts

@@ -12,6 +12,7 @@ export declare abstract class RemoteAppCommand extends AppCommand {
     app: App;
     appCreated: boolean;
     appType: string;
+    failedFiles: string[];
     protected pendingConflicts?: AppConflict[];
     storefront?: any;
     storefrontLocalUrl?: string;

package/dist/remote-app-command.js

@@ -5,7 +5,7 @@ import * as path from 'node:path';
 import { default as ora } from 'ora';
 import { AppCommand } from './app-command.js';
 import { readRcFile, writeRcFile } from './lib/app-config.js';
-import { AppConfig, ConfigType, FunctionProcessingError, IgnoringFileError, SwellJsonFields, allBaseFilesInDir, allConfigFilesPaths, appConfigFromFile, batchAppFilesByType, deleteFile, hashFile, writeFile, writeJsonFile, PUSH_CONCURRENCY, } from './lib/apps/index.js';
+import { AppConfig, ConfigType, FunctionProcessingError, IgnoringFileError, SwellJsonFields, allBaseFilesInDir, allConfigFilesPaths, appConfigFromFile, batchAppFilesByType, deleteFile, writeFile, writeJsonFile, PUSH_CONCURRENCY, } from './lib/apps/index.js';
 import { default as localConfig } from './lib/config.js';
 import { getAppFrontendHost, getLocalFrontendHost, getLoginHost, getStorefrontFrontendHost, } from './lib/constants.js';
 import { toAppId } from './lib/create/index.js';
@@ -24,6 +24,8 @@ export class RemoteAppCommand extends AppCommand {
     // Indicates the app was created during the command execution
     appCreated = false;
     appType = 'any';
+    // Files skipped because they could not be read or compiled
+    failedFiles = [];
     // Conflicts the user chose to disable, held until the command commits
     pendingConflicts;
     // API instance of the target storefront, if applicable
@@ -498,11 +500,11 @@ export class RemoteAppCommand extends AppCommand {
                     return true;
                 try {
                     const localConfig = localBatchConfigs.find((config) => config.filePath === batchConfig.filePath);
-                    if (localConfig) {
-                        const hash = hashFile(batchConfig.appPath, localConfig.fileData, batchConfig.filePath);
-                        if (hash === batchConfig.hash) {
-                            return false;
-                        }
+                    // Functions pushed by earlier CLI versions carry the plain file hash
+                    if (localConfig &&
+                        (localConfig.hash === batchConfig.hash ||
+                            localConfig.fileHash === batchConfig.hash)) {
+                        return false;
                     }
                 }
                 catch {
@@ -675,11 +677,13 @@ export class RemoteAppCommand extends AppCommand {
             if (error instanceof IgnoringFileError) {
                 log &&
                     spinner.fail(`Ignoring file: ${error.message} in ${config.filePath}`);
+                this.failedFiles.push(config.filePath);
                 return;
             }
             if (error instanceof FunctionProcessingError) {
                 log &&
                     spinner.fail(`${error.message} ${error.cause?.message?.toLowerCase()}`);
+                this.failedFiles.push(config.filePath);
                 return;
             }
             log && spinner.fail(error.message);

package/oclif.manifest.json

@@ -3594,5 +3594,5 @@
       ]
     }
   },
-  "version": "2.9.21"
+  "version": "2.9.22"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swell/cli",
-  "version": "2.9.21",
+  "version": "2.9.22",
   "type": "module",
   "description": "Swell's command line interface/utility",
   "keywords": [