@swell/cli 2.1.0 → 2.2.1

package/dist/lib/api.js

@@ -2,6 +2,14 @@ import fetch from 'node-fetch';
 import { stringify } from 'qs';
 import config from './config.js';
 import { API_BASE_URL, getAdminApiBaseUrl } from './constants.js';
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "get";
+    HttpMethod["POST"] = "post";
+    HttpMethod["PUT"] = "put";
+    HttpMethod["DELETE"] = "delete";
+})(HttpMethod || (HttpMethod = {}));
+const GET_ALL_LIMIT = 1000;
 const defaultHeaders = (opts) => ({
     'Content-Type': 'application/json',
     ...opts,
@@ -59,6 +67,9 @@ export default class Api {
         if (!path)
             throw new Error('Operation not supported.');
         const res = await fetch(path, fetchOptions);
+        if (options.rawResponse) {
+            return res;
+        }
         const resData = await res.text();
         if (!res.ok) {
             // Try to parse error message
@@ -84,31 +95,46 @@ export default class Api {
             return null;
         }
     }
-    async delete(pathOpts, options = {}) {
-        // ensure post body is stringified
-        if (options.body)
-            options.body = JSON.stringify(options.body);
-        const response = await this.api(pathOpts, {
-            method: 'DELETE',
-            ...options,
-        });
-        return this.waitForAsyncResponse(response, pathOpts, options);
-    }
     async get(pathOpts, options = {}) {
         return this.api(pathOpts, {
-            method: 'GET',
+            method: HttpMethod.GET,
             ...options,
         });
     }
-    isAdmin() {
-        return !this.secretKey;
+    async getAll(pathOpts, options = {}) {
+        const result = {
+            results: [],
+            count: 0,
+        };
+        let page = 1;
+        do {
+            // eslint-disable-next-line no-await-in-loop
+            const pageResult = await this.api(pathOpts, {
+                method: HttpMethod.GET,
+                ...options,
+                query: {
+                    limit: GET_ALL_LIMIT,
+                    ...options.query,
+                    page,
+                },
+            });
+            if (pageResult && pageResult.results) {
+                result.results = [...result.results, ...pageResult.results];
+                result.count = pageResult.count;
+                page++;
+            }
+            else {
+                break;
+            }
+        } while (result.count > result.results.length && result.results.length > 0);
+        return result;
     }
     async post(pathOpts, options = {}) {
         // ensure post body is stringified
         if (options.body)
             options.body = JSON.stringify(options.body);
         const response = await this.api(pathOpts, {
-            method: 'POST',
+            method: HttpMethod.POST,
             ...options,
         });
         return this.waitForAsyncResponse(response, pathOpts, options);
@@ -118,20 +144,20 @@ export default class Api {
         if (options.body)
             options.body = JSON.stringify(options.body);
         const response = await this.api(pathOpts, {
-            method: 'PUT',
+            method: HttpMethod.PUT,
             ...options,
         });
         return this.waitForAsyncResponse(response, pathOpts, options);
     }
-    async setStoreEnv(storeId, envId) {
-        if (envId) {
-            const hasTestEnv = await this.isTestEnvEnabled();
-            if (!hasTestEnv) {
-                throw new Error('Test environment is not enabled for this store.');
-            }
-        }
-        this.storeId = storeId;
-        this.envId = envId;
+    async delete(pathOpts, options = {}) {
+        // ensure post body is stringified
+        if (options.body)
+            options.body = JSON.stringify(options.body);
+        const response = await this.api(pathOpts, {
+            method: HttpMethod.DELETE,
+            ...options,
+        });
+        return this.waitForAsyncResponse(response, pathOpts, options);
     }
     async isTestEnvEnabled() {
         const clientRecord = await this.get({
@@ -139,6 +165,22 @@ export default class Api {
         });
         return clientRecord.test_enabled !== false;
     }
+    async setEnv(envId) {
+        const hasTestEnv = await this.isTestEnvEnabled();
+        if (!hasTestEnv) {
+            throw new Error('Test environment is not enabled for this store.');
+        }
+        this.envId = envId;
+    }
+    async setStoreEnv(storeId, envId) {
+        if (envId) {
+            await this.setEnv(envId);
+        }
+        this.storeId = storeId;
+    }
+    isAdmin() {
+        return !this.secretKey;
+    }
     truncatePath(path) {
         return path?.startsWith('/') ? path.slice(1) : path;
     }
@@ -151,7 +193,7 @@ export default class Api {
             setTimeout(resolve, 1000);
         });
         const asyncResponse = await this.api(onAsyncGetPath(response), {
-            method: 'GET',
+            method: HttpMethod.GET,
             onAsyncGetPath,
         });
         if (asyncResponse?.async_error) {

package/dist/lib/app-config.js

@@ -7,6 +7,7 @@ import * as path from 'node:path';
 const schema = {
     compatibilities: { type: 'object' },
     description: { type: 'string' },
+    extensions: { type: 'array' },
     id: { type: 'string' },
     integrations: { type: 'array' },
     name: { type: 'string' },

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

@@ -125,6 +125,8 @@ export interface FrontendProjectType {
     slug: string;
 }
 export declare const FrontendProjectTypes: FrontendProjectType[];
+export declare function getFrontendProjectSlugs(withNone?: boolean, withLegacy?: boolean): string[];
+export declare function getFrontendProjectValidValues(withNone?: boolean, withLegacy?: boolean): string;
 export declare function getAppSlugId(app: App): string | undefined;
 export declare function getFrontendProjectType(appPath: string): FrontendProjectType | undefined;
 export declare function getConfigTypeFromPath(path: string): ConfigType | undefined;

package/dist/lib/apps/index.js

@@ -46,7 +46,7 @@ const ConfigTypeBatchOrder = [
     ConfigType.FRONTEND,
     ConfigType.FILE,
 ];
-// Configs available for different app types
+// Configs available for admin/integration app types
 const StandardConfigTypes = [
     'MODEL',
     'CONTENT',
@@ -140,7 +140,7 @@ export const FrontendProjectTypes = [
     },
     {
         buildCommand: 'npm exec --workspace=frontend -- opennextjs-cloudflare build',
-        //devCommand: 'npm exec --workspace=frontend -- opennextjs-cloudflare build && npm exec --workspace=frontend -- opennextjs-cloudflare preview --port=${PORT}',
+        // devCommand: 'npm exec --workspace=frontend -- opennextjs-cloudflare build && npm exec --workspace=frontend -- opennextjs-cloudflare preview --port=${PORT}',
         devCommand: 'npm exec --workspace=frontend -- next dev --turbopack --port ${PORT}',
         installCommand: 'npm create cloudflare@latest -- frontend --framework=next --deploy=false --git=false -- --typescript --use-npm --src-dir --app --eslint --import-alias "@/*" --tailwind --turbopack',
         mainPackage: 'next',
@@ -148,6 +148,19 @@ export const FrontendProjectTypes = [
         slug: 'nextjs',
     },
 ];
+export function getFrontendProjectSlugs(withNone = true, withLegacy = true) {
+    const types = withLegacy
+        ? FrontendProjectTypes
+        : FrontendProjectTypes.filter((projectType) => projectType.installCommand);
+    const slugs = types.map((projectType) => projectType.slug);
+    if (withNone) {
+        slugs.push('none');
+    }
+    return slugs;
+}
+export function getFrontendProjectValidValues(withNone = true, withLegacy = true) {
+    return getFrontendProjectSlugs(withNone, withLegacy).join(', ');
+}
 export function getAppSlugId(app) {
     return toAppId(app.private_id) || app.public_id || app.id;
 }
@@ -158,7 +171,7 @@ function hasWorkspaceStructure(appPath) {
         return false;
     }
     try {
-        const content = fs.readFileSync(rootPkgPath, 'utf-8');
+        const content = fs.readFileSync(rootPkgPath, 'utf8');
         const pkg = JSON.parse(content);
         return Array.isArray(pkg.workspaces) && pkg.workspaces.includes('frontend');
     }
@@ -182,7 +195,7 @@ export function getFrontendProjectType(appPath) {
             continue;
         }
         try {
-            const content = fs.readFileSync(pkgPath, 'utf-8');
+            const content = fs.readFileSync(pkgPath, 'utf8');
             const pkg = JSON.parse(content);
             for (const projectType of projectTypes) {
                 if (pkg.dependencies?.[projectType.mainPackage] ||
@@ -190,16 +203,9 @@ export function getFrontendProjectType(appPath) {
                     // Create a copy to avoid mutating the original
                     const detectedType = { ...projectType };
                     // If buildCommand not explicitly set in framework definition, detect it
-                    if (detectedType.buildCommand === undefined) {
-                        // Check if package.json has a "build" script
-                        if (pkg.scripts?.build) {
-                            detectedType.buildCommand = 'npm run build';
-                        }
-                        else {
-                            // No build script found, set to empty string (no build needed)
-                            detectedType.buildCommand = '';
-                        }
-                    }
+                    detectedType.buildCommand ||=
+                        // Check if package.json has a "build" script, if not set to empty string (no build needed)
+                        pkg.scripts?.build ? 'npm run build' : '';
                     return detectedType;
                 }
             }

package/dist/lib/config.d.ts

@@ -8,8 +8,8 @@ declare function getAll(): any;
 declare function getDefaultStore(): string;
 declare function setDefaultStore(storeId: string): void;
 declare function getDefaultStorefront(appPath: string): {
-    id: string;
     env?: string;
+    id: string;
 };
 declare function setDefaultStorefront(appPath: string, storefrontId: string, env?: string): void;
 declare function getSessionId(storeId: string): any;

package/dist/lib/constants.d.ts

@@ -1,5 +1,6 @@
 export declare const API_BASE_URL: any;
 export declare const LOCAL_PROXY_PROVIDER: any;
+export declare const SCHEMAS_BASE_URL: any;
 export declare function getAdminApiBaseUrl(storeId: string): any;
 export declare function getLoginHost(storeId?: string): any;
 export declare function getAppFrontendHost(storeId: string, installedAppId: string): any;

package/dist/lib/constants.js

@@ -14,6 +14,7 @@ const STOREFRONT_FRONTEND_HOST = env.get('STOREFRONT_FRONTEND_HOST') ||
     env.get('STOREFRONT_PAGES_HOST') || // Deprecated
     defaultEnv.STOREFRONT_FRONTEND_HOST;
 export const LOCAL_PROXY_PROVIDER = env.get('LOCAL_PROXY_PROVIDER') || defaultEnv.LOCAL_PROXY_PROVIDER;
+export const SCHEMAS_BASE_URL = env.get('SCHEMAS_BASE_URL') || defaultEnv.SCHEMAS_BASE_URL;
 // helpers to get constants with replacements
 export function getAdminApiBaseUrl(storeId) {
     return ADMIN_API_BASE_URL.replace('${STORE_ID}', storeId);

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

@@ -1,4 +1,5 @@
 interface CreateContentFileBody {
+    $schema: string;
     collection: string;
     description?: string;
     fields?: ContentFieldProps[];
@@ -18,6 +19,9 @@ interface ContentFieldProps {
     label: string;
     type?: ContentType;
 }
+declare const validateViews: (values: string[], onError: (msg: string, options: {
+    exit: number;
+}) => never) => void;
 declare const parseViews: (views: string[]) => ContentViewProps[];
 declare const parseFields: (fields: string[]) => ContentFieldProps[];
-export { CreateContentFileBody, parseFields, parseViews };
+export { CreateContentFileBody, parseFields, parseViews, validateViews };

package/dist/lib/create/content.js

@@ -1,4 +1,11 @@
 import { titleize } from 'inflection';
+const validContentViewValues = ['list', 'edit', 'new'];
+const validateViews = (values, onError) => {
+    const invalid = values.filter((v) => !validContentViewValues.includes(v));
+    if (invalid.length > 0) {
+        onError(`Invalid view(s): ${invalid.join(', ')}\n\nValid views: ${validContentViewValues.join(', ')}\n\nExample: swell create content visitors -v list,edit,new -y`, { exit: 1 });
+    }
+};
 const parseViews = (views) => {
     if (views.length === 0) {
         return [];
@@ -37,4 +44,4 @@ const parseFields = (fields) => {
     }
     return fieldResponse;
 };
-export { parseFields, parseViews };
+export { parseFields, parseViews, validateViews };

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

@@ -7,11 +7,12 @@ interface CreateFunctionArgs {
 interface WriteFunctionFileParams {
     description: string;
     events: string;
+    extension?: string;
     functionName: string;
     language: FunctionLanguage;
     route: string;
     schedule: string;
     trigger: FunctionType;
 }
-declare const getFunctionTemplate: ({ description, events, language, route, schedule, trigger, }: WriteFunctionFileParams) => string;
+declare const getFunctionTemplate: ({ description, events, extension, language, route, schedule, trigger, }: WriteFunctionFileParams) => string;
 export { CreateFunctionArgs, FunctionLanguage, FunctionType, WriteFunctionFileParams, getFunctionTemplate, };

package/dist/lib/create/function.js

@@ -1,4 +1,4 @@
-const getFunctionTemplate = ({ description, events, language, route, schedule, trigger, }) => {
+const getFunctionTemplate = ({ description, events, extension, language, route, schedule, trigger, }) => {
     let typeAppend = ``;
     if (trigger === 'model') {
         const eventsList = events
@@ -24,12 +24,16 @@ const getFunctionTemplate = ({ description, events, language, route, schedule, t
     schedule: '${schedule}',
   },`;
     }
+    let extensionAppend = '';
+    if (extension) {
+        extensionAppend = `extension: '${extension}',\n  `;
+    }
     return `export const config${language === 'ts' ? ': SwellConfig' : ''} = {
-  description: '${description}'${typeAppend}
+  ${extensionAppend}description: '${description}'${typeAppend}
 };
 
 export default async function (req${language === 'ts' ? ': SwellRequest' : ''}) {
-  const { swell, store, settings, data${trigger === 'route' ? ', session' : ''} } = req;
+  const { swell, store, data } = req;
 }
 `;
 };

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

@@ -1,4 +1,5 @@
 interface CreateModelFileBody {
+    $schema: string;
     collection?: string;
     description?: string;
     events?: ModelEventObject;

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

@@ -0,0 +1,6 @@
+export declare const SCHEMAS: {
+    readonly CONTENT: "https://json.swell.store/content.json";
+    readonly MODEL: "https://json.swell.store/model.json";
+    readonly NOTIFICATION: "https://json.swell.store/notification.json";
+    readonly SETTING: "https://json.swell.store/setting.json";
+};

package/dist/lib/create/schemas.js

@@ -0,0 +1,6 @@
+export const SCHEMAS = {
+    CONTENT: 'https://json.swell.store/content.json',
+    MODEL: 'https://json.swell.store/model.json',
+    NOTIFICATION: 'https://json.swell.store/notification.json',
+    SETTING: 'https://json.swell.store/setting.json',
+};

package/dist/lib/create/tests/templates/env-dts.d.ts

@@ -0,0 +1 @@
+export declare function envDtsTemplate(): string;

package/dist/lib/create/tests/templates/env-dts.js

@@ -0,0 +1,14 @@
+export function envDtsTemplate() {
+    return `\
+declare module "cloudflare:test" {
+  interface ProvidedEnv {
+    SWELL_STORE_ID: string;
+    SWELL_SESSION_ID: string;
+    SWELL_API_BASE_URL: string;
+    SWELL_APP_ID: string;
+  }
+}
+
+export {};
+`;
+}

package/dist/lib/create/tests/templates/index.d.ts

@@ -0,0 +1,8 @@
+export { envDtsTemplate } from './env-dts.js';
+export { integrationTestTemplate } from './integration-test.js';
+export { mockRequestTemplate } from './mock-request.js';
+export { setupGlobalsTemplate } from './setup-globals.js';
+export { swellClientTemplate } from './swell-client.js';
+export { tsconfigTemplate } from './tsconfig.js';
+export { unitTestTemplate } from './unit-test.js';
+export { vitestConfigTemplate } from './vitest-config.js';

package/dist/lib/create/tests/templates/index.js

@@ -0,0 +1,8 @@
+export { envDtsTemplate } from './env-dts.js';
+export { integrationTestTemplate } from './integration-test.js';
+export { mockRequestTemplate } from './mock-request.js';
+export { setupGlobalsTemplate } from './setup-globals.js';
+export { swellClientTemplate } from './swell-client.js';
+export { tsconfigTemplate } from './tsconfig.js';
+export { unitTestTemplate } from './unit-test.js';
+export { vitestConfigTemplate } from './vitest-config.js';

package/dist/lib/create/tests/templates/integration-test.d.ts

@@ -0,0 +1 @@
+export declare function integrationTestTemplate(): string;

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

@@ -0,0 +1,19 @@
+export function integrationTestTemplate() {
+    return `\
+import { describe, it, expect } from "vitest";
+import { createSwellClient } from "../helpers/swell-client";
+
+describe("Store settings (read-only)", () => {
+  it("loads general store settings using CLI auth", async () => {
+    const swell = createSwellClient();
+
+    const general = await swell.get("/settings/general");
+
+    expect(general).toBeDefined();
+    expect(general.id).toBe("general");
+    expect(general.features).toBeDefined();
+    expect(typeof general.features.carts).toBe("boolean");
+  });
+});
+`;
+}

package/dist/lib/create/tests/templates/mock-request.d.ts

@@ -0,0 +1,2 @@
+import type { TestTemplateOptions } from '../types.js';
+export declare function mockRequestTemplate(options: TestTemplateOptions): string;

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

@@ -0,0 +1,112 @@
+export function mockRequestTemplate(options) {
+    return `\
+import { env } from "cloudflare:test";
+import { createSwellClient } from "./swell-client";
+
+export interface MockRequestOptions {
+  data?: SwellData;
+  query?: { [key: string]: string };
+  session?: { [key: string]: any };
+  headers?: Record<string, string>;
+  method?: string;
+  url?: string;
+  swell?: Partial<SwellAPI>;
+  store?: Partial<SwellStore>;
+  appId?: string;
+  useRealSwell?: boolean;
+}
+
+function createDefaultSwellMock(): Partial<SwellAPI> {
+  const notMocked = (method: string) => () => {
+    throw new Error(
+      \`swell.\${method}() not mocked. Pass { swell: { \${method}: vi.fn() } } to createMockRequest().\`
+    );
+  };
+  return {
+    get: notMocked("get"),
+    post: notMocked("post"),
+    put: notMocked("put"),
+    delete: notMocked("delete"),
+    settings: notMocked("settings"),
+  };
+}
+
+export function createMockRequest(options: MockRequestOptions = {}): SwellRequest {
+  const {
+    data = {},
+    query = {},
+    session = {},
+    headers = {},
+    method = "POST",
+    url = "https://example.com/test",
+    swell,
+    store,
+    appId,
+    useRealSwell = false,
+  } = options;
+
+  const requestHeaders = new Headers(headers);
+  const originalRequest = new Request(url, {
+    method,
+    headers: requestHeaders,
+    body: method === "GET" ? undefined : JSON.stringify(data),
+  });
+
+  const storeId = store?.id || env.SWELL_STORE_ID || "test-store";
+
+  const resolvedStore = {
+    id: storeId,
+    url: store?.url || "",
+    admin_url: store?.admin_url || "",
+  };
+
+  const context = {
+    waitUntil: async (promise: Promise<unknown>) => {
+      await promise;
+    },
+  };
+
+  const swellClient =
+    swell || (useRealSwell ? createSwellClient() : createDefaultSwellMock());
+
+  const resolvedAppId = appId || env.SWELL_APP_ID || "${options.appId}";
+
+  const req: Partial<SwellRequest> & { appId: string; storeId: string } = {
+    originalRequest,
+    context,
+    url,
+    method,
+    headers: requestHeaders,
+    referrer: originalRequest.referrer,
+    credentials: "include",
+    appId: resolvedAppId,
+    storeId,
+    accessToken: null,
+    publicKey: null,
+    store: resolvedStore,
+    session,
+    apiHost: env.SWELL_API_BASE_URL || "",
+    logParams: undefined,
+    swell: swellClient as SwellAPI,
+    body: data,
+    data,
+    query,
+    initialize: async () => {},
+    parseJson: (input: string) => JSON.parse(input),
+    appValues: (idOrValues: string | SwellData, values?: SwellData) => {
+      const targetAppId =
+        typeof idOrValues === "string" ? idOrValues : resolvedAppId;
+      const appValues = typeof idOrValues === "string" ? values : idOrValues;
+      if (!targetAppId || !appValues) return undefined;
+      return {
+        $app: {
+          [targetAppId]: appValues,
+        },
+      };
+    },
+  };
+
+  return req as SwellRequest;
+}
+`;
+}

package/dist/lib/create/tests/templates/setup-globals.d.ts

@@ -0,0 +1 @@
+export declare function setupGlobalsTemplate(): string;

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

@@ -0,0 +1,23 @@
+export function setupGlobalsTemplate() {
+    return `\
+class SwellErrorImpl extends Error {
+  status: number;
+
+  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;
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(globalThis as any).SwellError = SwellErrorImpl;
+
+export {};
+`;
+}

package/dist/lib/create/tests/templates/swell-client.d.ts

@@ -0,0 +1 @@
+export declare function swellClientTemplate(): string;