@celljs/cli 3.9.0 → 4.0.0

package/src/config/config-validator.ts

@@ -0,0 +1,208 @@
+import { CELL_EVENTS, CellError, EVENT_RULES, HOOKABLE_EVENTS } from '@celljs/kit';
+import { ConfigUtil } from '@celljs/vite';
+import { TextUtil } from '../utils/text-util.js';
+import type { CellConfig } from './types.js';
+
+type Path = readonly (string | number)[];
+
+/**
+ * Checks the shape of a loaded cell.config file. Every problem is a `CELL_CONFIG_INVALID` error that
+ * names the field, where it is written and how to fix it; likely typos get a "did you mean".
+ */
+export class ConfigValidator {
+    static readonly KEYS = ['preset', 'targets', 'modules', 'build', 'vite', 'hooks'];
+    static readonly TARGETS = ['frontend', 'backend'];
+    static readonly BUILD_KEYS = ['format', 'single', 'compile', 'external', 'sourcemap', 'outDir'];
+    static readonly FILTER_KEYS = ['source', 'runtime', 'toolchain'];
+    static readonly FORMATS = ['esm', 'cjs'];
+    static readonly COMPILE_TARGETS = ['bun', 'node', 'deno'];
+    static readonly PACKAGE_NAME = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+
+    /** @param source text of the file, used to report line numbers */
+    constructor(
+        protected readonly file: string,
+        protected readonly source = '',
+    ) {}
+
+    static isLocalPath(entry: string): boolean {
+        return entry.startsWith('.') || entry.startsWith('/');
+    }
+
+    validate(value: unknown): CellConfig {
+        if (!ConfigUtil.isPlainObject(value)) {
+            throw this.error([], `The default export is ${this.describe(value)}, not an object.`, 'Write `export default defineConfig({ ... })`.');
+        }
+        for (const [key, item] of Object.entries(value)) {
+            if (item === undefined) {
+                continue;
+            }
+            switch (key) {
+                case 'preset':
+                    this.expect(typeof item === 'string' && item !== '', [key], 'a preset name such as `node`', item);
+                    break;
+                case 'targets':
+                    this.targets(item);
+                    break;
+                case 'modules':
+                    this.modules(item);
+                    break;
+                case 'build':
+                    this.build(item);
+                    break;
+                case 'vite':
+                    this.expect(ConfigUtil.isPlainObject(item), [key], 'a Vite configuration object', item);
+                    break;
+                case 'hooks':
+                    this.hooks(item);
+                    break;
+                default:
+                    this.moduleOptions(key, item);
+            }
+        }
+        return value as CellConfig;
+    }
+
+    protected modules(value: unknown): void {
+        this.expect(Array.isArray(value), ['modules'], 'an array', value);
+        (value as unknown[]).forEach((entry, index) => {
+            const path = ['modules', index];
+            if (typeof entry === 'string') {
+                const name = entry.startsWith('!') ? entry.slice(1) : entry;
+                const valid = ConfigValidator.isLocalPath(entry) || ConfigValidator.PACKAGE_NAME.test(name);
+                this.expect(valid, path, "a relative path ('./modules/x'), a package name, or '!' and a package name", entry);
+                return;
+            }
+            this.expect(ConfigUtil.isPlainObject(entry), path, 'a string or `{ source, runtime?, toolchain? }`', entry);
+            const filter = entry as Record<string, unknown>;
+            this.unknownKeys(filter, ConfigValidator.FILTER_KEYS, path);
+            this.expect(
+                typeof filter.source === 'string' && ConfigValidator.PACKAGE_NAME.test(filter.source),
+                [...path, 'source'],
+                'a package name',
+                filter.source,
+            );
+            for (const key of ['runtime', 'toolchain']) {
+                this.expect(filter[key] === undefined || typeof filter[key] === 'boolean', [...path, key], 'a boolean', filter[key]);
+            }
+            if (filter.runtime !== false && filter.toolchain !== false) {
+                throw this.error(
+                    path,
+                    `The entry for ${filter.source} keeps everything, so it has no effect.`,
+                    `Set \`runtime: false\` or \`toolchain: false\`, or write '!${filter.source}' to leave the component out.`,
+                );
+            }
+        });
+    }
+
+    protected targets(value: unknown): void {
+        const list = value as unknown[];
+        const valid =
+            Array.isArray(value) && list.length > 0 && list.every(t => ConfigValidator.TARGETS.includes(t as string)) && new Set(list).size === list.length;
+        this.expect(valid, ['targets'], "a non-empty list of 'frontend' and 'backend' without duplicates", value);
+    }
+
+    protected build(value: unknown): void {
+        this.expect(ConfigUtil.isPlainObject(value), ['build'], 'an object', value);
+        const build = value as Record<string, unknown>;
+        this.unknownKeys(build, ConfigValidator.BUILD_KEYS, ['build']);
+        const optional = (key: string, ok: boolean, expected: string) => this.expect(build[key] === undefined || ok, ['build', key], expected, build[key]);
+        optional('format', ConfigValidator.FORMATS.includes(build.format as string), "'esm' or 'cjs'");
+        optional('single', typeof build.single === 'boolean', 'a boolean');
+        optional(
+            'compile',
+            typeof build.compile === 'boolean' || ConfigValidator.COMPILE_TARGETS.includes(build.compile as string),
+            "a boolean, 'bun', 'node' or 'deno'",
+        );
+        optional('external', Array.isArray(build.external) && build.external.every(name => typeof name === 'string'), 'an array of package names');
+        optional('sourcemap', typeof build.sourcemap === 'boolean', 'a boolean');
+        optional('outDir', typeof build.outDir === 'string' && build.outDir !== '', 'a directory relative to the project root');
+    }
+
+    protected hooks(value: unknown): void {
+        this.expect(ConfigUtil.isPlainObject(value), ['hooks'], 'an object of event names to hooks', value);
+        for (const [event, hook] of Object.entries(value as Record<string, unknown>)) {
+            if (!(CELL_EVENTS as readonly string[]).includes(event)) {
+                const suggestion = TextUtil.closest(event, CELL_EVENTS, 3);
+                throw this.error(
+                    ['hooks', event],
+                    `Unknown event '${event}'.`,
+                    suggestion ? `Did you mean '${suggestion}'?` : `Use one of: ${CELL_EVENTS.join(', ')}.`,
+                );
+            }
+            if (EVENT_RULES[event as keyof typeof EVENT_RULES] === 'mutate') {
+                throw this.error(
+                    ['hooks', event],
+                    `'${event}' lets handlers change the event object, which a command cannot do.`,
+                    `Subscribe with cell.on('${event}', ...) in a local module, or run the command on one of: ${HOOKABLE_EVENTS.join(', ')}.`,
+                );
+            }
+            if (typeof hook === 'function') {
+                throw this.error(
+                    ['hooks', event],
+                    `hooks['${event}'] is a function; hooks only run shell commands.`,
+                    `Move the function into a local module (export default (cell) => cell.on('${event}', ...)) and list it in \`modules\`.`,
+                );
+            }
+            this.expect(typeof hook === 'string' && hook.trim() !== '', ['hooks', event], 'a shell command', hook);
+        }
+    }
+
+    /** Any other top-level field holds the options of a toolchain module, read with `cell.options(key)`. */
+    protected moduleOptions(key: string, value: unknown): void {
+        const suggestion = TextUtil.closest(key, ConfigValidator.KEYS, key.length >= 5 ? 2 : 1);
+        if (suggestion) {
+            throw this.error([key], `Unknown field '${key}'.`, `Did you mean '${suggestion}'?`);
+        }
+        if (!ConfigUtil.isPlainObject(value)) {
+            throw this.error(
+                [key],
+                `'${key}' is ${this.describe(value)}; options of a toolchain module must be an object.`,
+                `Write \`${key}: { ... }\`. To turn a component off, add '!<package>' to \`modules\`.`,
+            );
+        }
+    }
+
+    protected unknownKeys(value: Record<string, unknown>, known: readonly string[], path: Path): void {
+        for (const key of Object.keys(value)) {
+            if (!known.includes(key)) {
+                const suggestion = TextUtil.closest(key, known);
+                throw this.error(
+                    [...path, key],
+                    `Unknown field '${key}'.`,
+                    suggestion ? `Did you mean '${suggestion}'?` : `Known fields: ${known.join(', ')}.`,
+                );
+            }
+        }
+    }
+
+    protected expect(ok: boolean, path: Path, expected: string, actual: unknown): void {
+        if (!ok) {
+            throw this.error(path, `${this.format(path)} must be ${expected}, got ${this.describe(actual)}.`, `Change ${this.format(path)} to ${expected}.`);
+        }
+    }
+
+    protected error(path: Path, message: string, hint: string): CellError {
+        const position = TextUtil.locate(this.source, path);
+        return new CellError({ code: 'CELL_CONFIG_INVALID', message, hint, file: this.file, line: position?.line, column: position?.column });
+    }
+
+    protected format(path: Path): string {
+        return path.map((key, i) => (typeof key === 'number' ? `[${key}]` : /^[A-Za-z_$][\w$]*$/.test(key) ? `${i ? '.' : ''}${key}` : `['${key}']`)).join('');
+    }
+
+    protected describe(value: unknown): string {
+        if (value === undefined || value === null) {
+            return String(value);
+        }
+        if (typeof value === 'function') {
+            return 'a function';
+        }
+        if (Array.isArray(value)) {
+            return 'an array';
+        }
+        if (typeof value === 'object') {
+            return 'an object';
+        }
+        return JSON.stringify(value);
+    }
+}

package/src/config/define-config.ts

@@ -0,0 +1,6 @@
+import type { CellConfig } from './types.js';
+
+/** Types the default export of cell.config.ts; returns it unchanged. */
+export function defineConfig(config: CellConfig): CellConfig {
+    return config;
+}

package/src/config/types.ts

@@ -0,0 +1,57 @@
+import type { CellModuleOptions, HookableEventName, Target } from '@celljs/kit';
+import type { UserConfig } from 'vite';
+
+/** Targets of `cell build --compile`: the runtime that produces the executable. */
+export type CompileTarget = 'bun' | 'node' | 'deno';
+
+export interface BuildOptions {
+    /** Server bundle format. Default: the preset's format, else `esm`. Node executables need `cjs`. */
+    format?: 'esm' | 'cjs';
+    /** Embed the frontend into the server bundle: one file runs the whole application. */
+    single?: boolean;
+    /** Produce one executable file; `true` means `bun`. */
+    compile?: boolean | CompileTarget;
+    /** Packages the server bundle must not inline; they are copied next to it. */
+    external?: string[];
+    sourcemap?: boolean;
+    /** Output directory, relative to the project root. Default `.cell/output`. */
+    outDir?: string;
+}
+
+/** Narrows what a component contributes: `runtime: false` drops its DI modules, `toolchain: false` its toolchain module. */
+export interface ModuleFilter {
+    source: string;
+    runtime?: boolean;
+    toolchain?: boolean;
+}
+
+/**
+ * One entry of `modules`:
+ * - `'./modules/audit'` — a toolchain module of the project (a file, or a directory with a package.json);
+ * - `'@scope/name'` — the toolchain module of a package that is not a runtime dependency;
+ * - `'!@scope/name'` — leave a component out entirely;
+ * - `{ source, runtime?, toolchain? }` — keep a component but drop part of it.
+ */
+export type ModuleEntry = string | ModuleFilter;
+
+/**
+ * cell.config.ts: configuration of the toolchain only. Application configuration (what `@Value`
+ * reads) belongs in cell.yml (docs/design/agent-first.md R1). Every other top-level field is the
+ * options object of a toolchain module, typed through {@link CellModuleOptions}.
+ */
+export interface CellConfig extends CellModuleOptions {
+    /** Shape of the output, e.g. `node`, `fc`. Overridden by `--preset`; falls back to `CELL_PRESET`, CI detection, `node`. */
+    preset?: string;
+    /** Targets to build, replacing the default: `backend` plus the components' `targets` (e.g. `@celljs/widget` adds `frontend`). */
+    targets?: Target[];
+    modules?: ModuleEntry[];
+    build?: BuildOptions;
+    /** Merged into the Vite configuration of every environment. */
+    vite?: UserConfig;
+    /**
+     * Shell commands run on toolchain events, e.g. `{ 'build:before': 'prisma generate' }`. Only notification
+     * and gate events; a failing command cancels a gate event and fails the command otherwise. Anything that
+     * needs code belongs in a local module.
+     */
+    hooks?: Partial<Record<HookableEventName, string>>;
+}

package/src/deploy/cloud-api.ts

@@ -0,0 +1,194 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { CellError, type StandardSchema } from '@celljs/kit';
+
+/** What the clouds' API clients need from the outside world; tests replace it. */
+export interface CloudIo {
+    fetch(url: string, init: RequestInit): Promise<Response>;
+    sleep(ms: number): Promise<void>;
+    now(): Date;
+}
+
+export const DEFAULT_IO: CloudIo = {
+    fetch: (input, init) => fetch(input, init),
+    sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
+    now: () => new Date(),
+};
+
+/** An error answer of a cloud API, with the cloud's own code. */
+export class CloudApiError extends Error {
+    constructor(
+        readonly status: number,
+        readonly code: string,
+        message: string,
+        readonly requestId?: string,
+    ) {
+        super(message);
+    }
+}
+
+export namespace CloudApi {
+    /** Sends a request; a network failure becomes CELL_DEPLOY_NETWORK. */
+    export async function send(io: CloudIo, url: string, init: RequestInit, cloud: string): Promise<Response> {
+        try {
+            return await io.fetch(url, init);
+        } catch (cause) {
+            throw new CellError({
+                code: 'CELL_DEPLOY_NETWORK',
+                message: `Cannot reach ${new URL(url).host} (${cloud}): ${(cause as Error)?.message ?? cause}`,
+                hint: 'Check the network connection and proxy settings of this machine, then deploy again.',
+                cause,
+            });
+        }
+    }
+
+    /** A failed API call as a CellError for people and agents. */
+    export function failure(cloud: string, step: string, error: CloudApiError, hint?: string): CellError {
+        const auth = error.status === 401 || error.status === 403 || /auth|signature|accesskey|secret|credential|forbidden|denied|token/i.test(error.code);
+        return new CellError({
+            code: auth ? 'CELL_DEPLOY_UNAUTHORIZED' : 'CELL_DEPLOY_API_ERROR',
+            message: `${cloud} ${step} failed: [${error.code}] ${error.message}${error.requestId ? ` (request ${error.requestId})` : ''}`,
+            hint:
+                hint ??
+                (auth
+                    ? 'Check that the credentials are valid and allowed to manage functions in this account and region.'
+                    : 'Fix what the cloud reports (see the code and message), then deploy again.'),
+        });
+    }
+
+    export async function poll<T>(io: CloudIo, read: () => Promise<T>, done: (value: T) => boolean, what: string, timeoutMs = 180_000): Promise<T> {
+        const started = io.now().getTime();
+        for (let delay = 1000; ; delay = Math.min(delay * 1.5, 5000)) {
+            const value = await read();
+            if (done(value)) {
+                return value;
+            }
+            if (io.now().getTime() - started > timeoutMs) {
+                throw new CellError({
+                    code: 'CELL_DEPLOY_TIMEOUT',
+                    message: `Timed out after ${Math.round(timeoutMs / 1000)}s waiting for ${what}.`,
+                    hint: 'Look at the function in the console of the cloud; deploy again once it is ready.',
+                });
+            }
+            await io.sleep(delay);
+        }
+    }
+}
+
+/** Credentials of each cloud, from the environment variables their own CLIs and SDKs read. */
+export namespace CloudCredentials {
+    export function alibaba(env: NodeJS.ProcessEnv): { accessKeyId: string; accessKeySecret: string; securityToken?: string } | undefined {
+        const accessKeyId = env.ALIBABA_CLOUD_ACCESS_KEY_ID;
+        const accessKeySecret = env.ALIBABA_CLOUD_ACCESS_KEY_SECRET;
+        return accessKeyId && accessKeySecret ? { accessKeyId, accessKeySecret, securityToken: env.ALIBABA_CLOUD_SECURITY_TOKEN || undefined } : undefined;
+    }
+
+    export function tencent(env: NodeJS.ProcessEnv): { secretId: string; secretKey: string; token?: string } | undefined {
+        const secretId = env.TENCENTCLOUD_SECRET_ID;
+        const secretKey = env.TENCENTCLOUD_SECRET_KEY;
+        return secretId && secretKey ? { secretId, secretKey, token: env.TENCENTCLOUD_SESSION_TOKEN || undefined } : undefined;
+    }
+
+    /** `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`, else the `AWS_PROFILE` (or default) profile of ~/.aws/credentials. */
+    export function aws(env: NodeJS.ProcessEnv, home = homedir()): { accessKeyId: string; secretAccessKey: string; sessionToken?: string } | undefined {
+        if (env.AWS_ACCESS_KEY_ID && env.AWS_SECRET_ACCESS_KEY) {
+            return { accessKeyId: env.AWS_ACCESS_KEY_ID, secretAccessKey: env.AWS_SECRET_ACCESS_KEY, sessionToken: env.AWS_SESSION_TOKEN || undefined };
+        }
+        const file = env.AWS_SHARED_CREDENTIALS_FILE ?? join(home, '.aws', 'credentials');
+        if (!existsSync(file)) {
+            return undefined;
+        }
+        const section = ini(readFileSync(file, 'utf8'))[env.AWS_PROFILE ?? 'default'];
+        return section?.aws_access_key_id && section.aws_secret_access_key
+            ? { accessKeyId: section.aws_access_key_id, secretAccessKey: section.aws_secret_access_key, sessionToken: section.aws_session_token }
+            : undefined;
+    }
+
+    export function ini(text: string): Record<string, Record<string, string>> {
+        const sections: Record<string, Record<string, string>> = {};
+        let current: Record<string, string> | undefined;
+        for (const raw of text.split(/\r?\n/)) {
+            const line = raw.trim();
+            const header = /^\[\s*(?:profile\s+)?([^\]]+?)\s*\]$/.exec(line);
+            if (header) {
+                current = sections[header[1]] ??= {};
+            } else if (current && /^[\w.-]+\s*=/.test(line)) {
+                const index = line.indexOf('=');
+                current[line.slice(0, index).trim()] = line.slice(index + 1).trim();
+            }
+        }
+        return sections;
+    }
+
+    export function missing(cloud: string, variables: string, more = ''): CellError {
+        return new CellError({
+            code: 'CELL_DEPLOY_CREDENTIALS_MISSING',
+            message: `No ${cloud} credentials: ${variables} are not set.`,
+            hint: `Set ${variables} in the environment of cell deploy (CI secrets, or your shell)${more}. cell deploy --dry-run works without them.`,
+        });
+    }
+}
+
+type FieldType = 'string' | 'number' | 'boolean' | 'env' | readonly string[];
+
+/**
+ * A Standard Schema for the options of a preset (its field of cell.config.ts), without a
+ * validation library: known keys only, each of one type; `env` is a record of strings.
+ */
+export namespace PresetOptionsSchema {
+    export function of(fields: Record<string, FieldType>): StandardSchema {
+        return {
+            '~standard': {
+                version: 1,
+                vendor: 'cell',
+                validate: value => {
+                    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                        return { issues: [{ message: 'must be an object' }] };
+                    }
+                    for (const [key, field] of Object.entries(value as Record<string, unknown>)) {
+                        const type = fields[key];
+                        const problem = type === undefined ? `unknown option; the options are ${Object.keys(fields).join(', ')}` : check(field, type);
+                        if (problem) {
+                            return { issues: [{ message: problem, path: [key] }] };
+                        }
+                    }
+                    return { value };
+                },
+            },
+        };
+    }
+
+    function check(value: unknown, type: FieldType): string | undefined {
+        if (Array.isArray(type)) {
+            return type.includes(value as string) ? undefined : `must be one of ${type.map(t => JSON.stringify(t)).join(', ')}`;
+        }
+        if (type === 'env') {
+            const ok = typeof value === 'object' && value !== null && !Array.isArray(value) && Object.values(value).every(v => typeof v === 'string');
+            return ok ? undefined : 'must be an object of strings';
+        }
+        if (type === 'number') {
+            return typeof value === 'number' && Number.isFinite(value) && value > 0 ? undefined : 'must be a positive number';
+        }
+        return typeof value === type ? undefined : `must be a ${type}`;
+    }
+}
+
+/** Names of cloud resources derived from the package name. */
+export namespace CloudNames {
+    /** Letters, digits and `-`, starting with a letter, at most `max` characters. */
+    export function functionName(root: string, given: unknown, max = 60): string {
+        if (typeof given === 'string' && given) {
+            return given;
+        }
+        const file = join(root, 'package.json');
+        const pkg = existsSync(file) ? (JSON.parse(readFileSync(file, 'utf8')) as { name?: string }).name : undefined;
+        const base = (pkg ?? 'cell-app')
+            .replace(/^@[^/]+\//, '')
+            .toLowerCase()
+            .replace(/[^a-z0-9-]+/g, '-')
+            .replace(/^[^a-z]+/, '')
+            .replace(/-+$/, '');
+        return (base || 'cell-app').slice(0, max).replace(/-+$/, '');
+    }
+}

package/src/deploy/code-package.ts

@@ -0,0 +1,44 @@
+import { CellError } from '@celljs/kit';
+import { ZipWriter } from './zip-writer.js';
+
+/** The zip of a build output that function platforms take as code. */
+export class CodePackage {
+    protected constructor(
+        readonly zip: Buffer,
+        readonly files: number,
+    ) {}
+
+    /** Every file of the output directory. */
+    static of(outDir: string): CodePackage {
+        const writer = new ZipWriter();
+        writer.addDirectory(outDir);
+        return new CodePackage(writer.toBuffer(), writer.files);
+    }
+
+    get size(): number {
+        return this.zip.length;
+    }
+
+    get base64(): string {
+        return this.zip.toString('base64');
+    }
+
+    describe(): string {
+        return `${CodePackage.bytes(this.size)} zipped, ${this.files} files`;
+    }
+
+    /** Fails before uploading when the platform would reject the package. */
+    checkSize(limit: number, cloud: string, hint: string): void {
+        if (this.size > limit) {
+            throw new CellError({
+                code: 'CELL_DEPLOY_PACKAGE_TOO_LARGE',
+                message: `The code package is ${CodePackage.bytes(this.size)}; ${cloud} accepts at most ${CodePackage.bytes(limit)} in a direct upload.`,
+                hint,
+            });
+        }
+    }
+
+    static bytes(n: number): string {
+        return n >= 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(n / 1024))} KB`;
+    }
+}

package/src/deploy/deployer-registry.ts

@@ -0,0 +1,44 @@
+import { CellError, type Deployer } from '@celljs/kit';
+import { cloudflareDeployer } from '../preset/cloudflare/cloudflare-deployer.js';
+import { fcDeployer } from '../preset/fc/fc-deployer.js';
+import { lambdaDeployer } from '../preset/lambda/lambda-deployer.js';
+import { scfDeployer } from '../preset/scf/scf-deployer.js';
+import { vercelDeployer } from '../preset/vercel/vercel-deployer.js';
+
+/** Deployers by name; a preset names the one that publishes its output (`Preset.deployer`). */
+export class DeployerRegistry {
+    protected readonly deployers = new Map<string, Deployer>();
+
+    /** The deployers that come with the CLI. */
+    static builtin(): DeployerRegistry {
+        return new DeployerRegistry().register(cloudflareDeployer).register(fcDeployer).register(scfDeployer).register(lambdaDeployer).register(vercelDeployer);
+    }
+
+    register(deployer: Deployer): this {
+        if (this.deployers.has(deployer.name)) {
+            throw new CellError({
+                code: 'CELL_DEPLOYER_DUPLICATE',
+                message: `Deployer '${deployer.name}' is registered twice.`,
+                hint: 'Give the deployer another name.',
+            });
+        }
+        this.deployers.set(deployer.name, deployer);
+        return this;
+    }
+
+    get names(): string[] {
+        return [...this.deployers.keys()];
+    }
+
+    get(name: string): Deployer {
+        const deployer = this.deployers.get(name);
+        if (!deployer) {
+            throw new CellError({
+                code: 'CELL_DEPLOYER_NOT_FOUND',
+                message: `Unknown deployer '${name}'. Available: ${this.names.join(', ') || 'none'}.`,
+                hint: 'Use a preset whose deployer is available, or add the module that provides it.',
+            });
+        }
+        return deployer;
+    }
+}