@youcan/app 2.1.4 → 2.3.0

package/dist/cli/services/dev/workers/theme-extension-worker.js

@@ -1,117 +1,117 @@
-import { Worker, Color, Session, Http, Env, Path, Filesystem, Form } from '@youcan/cli-kit';
+import { Worker, Session, Http, Env, Path, Filesystem, Form } from '@youcan/cli-kit';
 
-class ThemeExtensionWorker extends Worker.Abstract {
-    command;
-    app;
-    extension;
-    logger;
-    queue = [];
-    FILE_TYPES = [
-        'assets',
-        'locales',
-        'snippets',
-        'blocks',
-    ];
-    constructor(command, app, extension) {
-        super();
-        this.command = command;
-        this.app = app;
-        this.extension = extension;
-        this.logger = new Worker.Logger('stdout', 'extensions', Color.yellow);
-    }
-    async boot() {
-        const session = await Session.authenticate(this.command);
-        try {
-            const res = await Http.post(`${Env.apiHostname()}/apps/${this.app.config.id}/extensions/create`, {
-                headers: { Authorization: `Bearer ${session.access_token}` },
-                body: JSON.stringify({ ...this.extension.config }),
-            });
-            this.extension.id = res.id;
-            this.extension.metadata = res.metadata;
-        }
-        catch (err) {
-            this.command.error(err);
-        }
-    }
-    async run() {
-        this.logger.write(`pushed '${this.extension.config.name}' to a draft...`);
-        for (const type of this.FILE_TYPES) {
-            const descriptors = this.extension.metadata[type] ?? [];
-            const directory = Path.resolve(this.extension.root, type);
-            const present = await Filesystem.exists(directory)
-                ? await Filesystem.readdir(directory)
-                : [];
-            present.filter(f => !descriptors.find(d => d.file_name === f))
-                .forEach(async (file) => this.enqueue('put', type, file));
-            descriptors.forEach(async (descriptor) => {
-                const path = Path.resolve(directory, descriptor.file_name);
-                if (!(await Filesystem.exists(path))) {
-                    return this.enqueue('del', type, descriptor.file_name);
-                }
-                this.enqueue('put', type, descriptor.file_name);
-            });
-        }
-        const paths = this.FILE_TYPES
-            .map(p => Path.resolve(this.extension.root, p));
-        const watcher = Filesystem.watch(paths, {
-            persistent: true,
-            ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: 50,
-            },
-        });
-        this.command.controller.signal.addEventListener('abort', () => {
-            watcher.close();
-        });
-        watcher.on('all', async (event, path) => {
-            try {
-                if (!['add', 'change', 'unlink'].includes(event)) {
-                    return;
-                }
-                const [filetype, filename] = [
-                    Path.basename(Path.dirname(path)),
-                    Path.basename(path),
-                ];
-                switch (event) {
-                    case 'add':
-                    case 'change':
-                        this.enqueue('put', filetype, filename);
-                        break;
-                    case 'unlink':
-                        this.enqueue('del', filetype, filename);
-                        break;
-                }
-            }
-            catch (err) {
-                this.command.output.warn(err);
-            }
-        });
-        // quick racing conditions hack
-        setInterval(async () => {
-            const task = this.queue.shift();
-            if (task == null) {
-                return;
-            }
-            await task();
-        }, 10);
-    }
-    enqueue(op, type, name) {
-        this.queue.push(async () => {
-            const path = Path.join(this.extension.root, type, name);
-            const payload = {
-                file_name: name,
-                file_type: type,
-                file_operation: op,
-            };
-            if (op === 'put') {
-                payload.file_content = await Form.file(path);
-            }
-            await Http.post(`${Env.apiHostname()}/apps/${this.app.config.id}/extensions/${this.extension.id}/file`, {
-                body: Form.convert(payload),
-            });
-            this.logger.write(`[${op === 'put' ? 'updated' : 'deleted'}] - ${Path.join(type, name)}`);
-        });
-    }
+class ThemeExtensionWorker extends Worker.Abstract {
+    command;
+    app;
+    extension;
+    logger;
+    queue = [];
+    FILE_TYPES = [
+        'assets',
+        'locales',
+        'snippets',
+        'blocks',
+    ];
+    constructor(command, app, extension) {
+        super();
+        this.command = command;
+        this.app = app;
+        this.extension = extension;
+        this.logger = new Worker.Logger('extensions', 'yellow');
+    }
+    async boot() {
+        const session = await Session.authenticate(this.command);
+        try {
+            const res = await Http.post(`${Env.apiHostname()}/apps/${this.app.config.id}/extensions/create`, {
+                headers: { Authorization: `Bearer ${session.access_token}` },
+                body: JSON.stringify({ ...this.extension.config }),
+            });
+            this.extension.id = res.id;
+            this.extension.metadata = res.metadata;
+        }
+        catch (err) {
+            this.command.error(err);
+        }
+    }
+    async run() {
+        this.logger.write(`pushed '${this.extension.config.name}' to a draft...`);
+        for (const type of this.FILE_TYPES) {
+            const descriptors = this.extension.metadata[type] ?? [];
+            const directory = Path.resolve(this.extension.root, type);
+            const present = await Filesystem.exists(directory)
+                ? await Filesystem.readdir(directory)
+                : [];
+            present.filter(f => !descriptors.find(d => d.file_name === f))
+                .forEach(async (file) => this.enqueue('put', type, file));
+            descriptors.forEach(async (descriptor) => {
+                const path = Path.resolve(directory, descriptor.file_name);
+                if (!(await Filesystem.exists(path))) {
+                    return this.enqueue('del', type, descriptor.file_name);
+                }
+                this.enqueue('put', type, descriptor.file_name);
+            });
+        }
+        const paths = this.FILE_TYPES
+            .map(p => Path.resolve(this.extension.root, p));
+        const watcher = Filesystem.watch(paths, {
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 50,
+            },
+        });
+        this.command.controller.signal.addEventListener('abort', () => {
+            watcher.close();
+        });
+        watcher.on('all', async (event, path) => {
+            try {
+                if (!['add', 'change', 'unlink'].includes(event)) {
+                    return;
+                }
+                const [filetype, filename] = [
+                    Path.basename(Path.dirname(path)),
+                    Path.basename(path),
+                ];
+                switch (event) {
+                    case 'add':
+                    case 'change':
+                        this.enqueue('put', filetype, filename);
+                        break;
+                    case 'unlink':
+                        this.enqueue('del', filetype, filename);
+                        break;
+                }
+            }
+            catch (err) {
+                this.command.output.warn(err);
+            }
+        });
+        // quick racing conditions hack
+        setInterval(async () => {
+            const task = this.queue.shift();
+            if (task == null) {
+                return;
+            }
+            await task();
+        }, 10);
+    }
+    enqueue(op, type, name) {
+        this.queue.push(async () => {
+            const path = Path.join(this.extension.root, type, name);
+            const payload = {
+                file_name: name,
+                file_type: type,
+                file_operation: op,
+            };
+            if (op === 'put') {
+                payload.file_content = await Form.file(path);
+            }
+            await Http.post(`${Env.apiHostname()}/apps/${this.app.config.id}/extensions/${this.extension.id}/file`, {
+                body: Form.convert(payload),
+            });
+            this.logger.write(`[${op === 'put' ? 'updated' : 'deleted'}] - ${Path.join(type, name)}`);
+        });
+    }
 }
 
 export { ThemeExtensionWorker as default };

package/dist/cli/services/dev/workers/tunnel-worker.d.ts

@@ -0,0 +1,15 @@
+import { Worker } from '@youcan/cli-kit';
+import type { Services } from '@youcan/cli-kit';
+import type { App } from '@/types';
+import type { AppCommand } from '@/util/app-command';
+export default class TunnelWorker extends Worker.Abstract {
+    private command;
+    private app;
+    private tunnelService;
+    private readonly logger;
+    private url;
+    constructor(command: AppCommand, app: App, tunnelService: Services.Cloudflared);
+    boot(): Promise<void>;
+    run(): Promise<void>;
+    private checkForError;
+}

package/dist/cli/services/dev/workers/tunnel-worker.js

@@ -0,0 +1,57 @@
+import { Worker, System } from '@youcan/cli-kit';
+
+class TunnelWorker extends Worker.Abstract {
+    command;
+    app;
+    tunnelService;
+    logger;
+    url = null;
+    constructor(command, app, tunnelService) {
+        super();
+        this.command = command;
+        this.app = app;
+        this.tunnelService = tunnelService;
+        this.logger = new Worker.Logger('tunnel', 'dim');
+    }
+    async boot() {
+        if (!this.app.networkConfig) {
+            throw new Error('app network config is not set');
+        }
+        this.logger.write('start tunneling the app');
+        await this.tunnelService.tunnel(this.app.networkConfig.port);
+        // Stop the execution for while and see if the tunnel is available.
+        await System.sleep(5);
+        const url = this.tunnelService.getUrl();
+        if (url) {
+            this.logger.write(`tunneled url obtained: \`${url}\``);
+            this.url = url;
+            this.app.networkConfig.appUrl = this.url;
+        }
+    }
+    async run() {
+        const timeInterval = 500;
+        if (this.url) {
+            return;
+        }
+        setInterval(() => {
+            if (this.url !== null) {
+                this.checkForError();
+                return;
+            }
+            this.url = this.tunnelService.getUrl();
+            if (this.url) {
+                this.logger.write(`tunneled url obtained: \`${this.url}\``);
+                this.app.networkConfig.appUrl = this.url;
+                this.command.syncAppConfig();
+            }
+        }, timeInterval);
+    }
+    checkForError() {
+        const error = this.tunnelService.getError();
+        if (error) {
+            throw new Error(`Tunnel stopped: ${error}`);
+        }
+    }
+}
+
+export { TunnelWorker as default };

package/dist/cli/services/dev/workers/web-worker.d.ts

@@ -1,11 +1,12 @@
-import { type Cli, Worker } from '@youcan/cli-kit';
-import type { App, Web } from '@/types';
-export default class WebWorker extends Worker.Abstract {
-    private command;
-    private app;
-    private web;
-    private logger;
-    constructor(command: Cli.Command, app: App, web: Web);
-    boot(): Promise<void>;
-    run(): Promise<void>;
-}
+import { type Cli, Worker } from '@youcan/cli-kit';
+import type { App, Web } from '@/types';
+export default class WebWorker extends Worker.Abstract {
+    private readonly command;
+    private readonly app;
+    private readonly web;
+    private readonly env;
+    private logger;
+    constructor(command: Cli.Command, app: App, web: Web, env: Record<string, string>);
+    boot(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/cli/services/dev/workers/web-worker.js

@@ -1,27 +1,30 @@
-import { Worker, Color, System } from '@youcan/cli-kit';
+import { Worker, System } from '@youcan/cli-kit';
 
-class WebWorker extends Worker.Abstract {
-    command;
-    app;
-    web;
-    logger;
-    constructor(command, app, web) {
-        super();
-        this.command = command;
-        this.app = app;
-        this.web = web;
-        this.logger = new Worker.Logger('stderr', this.web.config.name || 'web', Color.blue);
-    }
-    async boot() {
-    }
-    async run() {
-        const [cmd, ...args] = this.web.config.commands.dev.split(' ');
-        return System.exec(cmd, args, {
-            stdout: this.logger,
-            signal: this.command.controller.signal,
-            stderr: new Worker.Logger('stderr', this.web.config.name || 'web', Color.red),
-        });
-    }
+class WebWorker extends Worker.Abstract {
+    command;
+    app;
+    web;
+    env;
+    logger;
+    constructor(command, app, web, env) {
+        super();
+        this.command = command;
+        this.app = app;
+        this.web = web;
+        this.env = env;
+        this.logger = new Worker.Logger(this.web.config.name || 'web', 'blue');
+    }
+    async boot() {
+    }
+    async run() {
+        const [cmd, ...args] = this.web.config.commands.dev.split(' ');
+        return System.exec(cmd, args, {
+            stdout: this.logger,
+            signal: this.command.controller.signal,
+            stderr: new Worker.Logger(this.web.config.name || 'web', 'red'),
+            env: this.env,
+        });
+    }
 }
 
 export { WebWorker as default };

package/dist/cli/services/generate/extensions/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../../../../types").ExtensionTemplate[];
-export default _default;
+declare const _default: import("../../../../types").ExtensionTemplate[];
+export default _default;

package/dist/cli/services/generate/extensions/index.js

@@ -1,7 +1,7 @@
 import ThemeExtension from './theme-extension.js';
 
-var extensions = [
-    ThemeExtension,
+var extensions = [
+    ThemeExtension,
 ];
 
 export { extensions as default };

package/dist/cli/services/generate/extensions/theme-extension.d.ts

@@ -1,3 +1,3 @@
-import type { ExtensionTemplate } from '@/types';
-declare const _default: ExtensionTemplate;
-export default _default;
+import type { ExtensionTemplate } from '@/types';
+declare const _default: ExtensionTemplate;
+export default _default;

package/dist/cli/services/generate/extensions/theme-extension.js

@@ -1,20 +1,20 @@
-var ThemeExtension = {
-    name: 'Theme extension',
-    identifier: 'theme-extension',
-    description: 'Liquid snippets to extend store themes',
-    types: [
-        {
-            url: 'https://github.com/youcan-shop/app-extension-templates',
-            type: 'theme',
-            flavors: [
-                {
-                    name: 'Liquid',
-                    value: 'liquid',
-                    path: 'theme-extension/liquid',
-                },
-            ],
-        },
-    ],
+var ThemeExtension = {
+    name: 'Theme extension',
+    identifier: 'theme-extension',
+    description: 'Liquid snippets to extend store themes',
+    types: [
+        {
+            url: 'https://github.com/youcan-shop/app-extension-templates',
+            type: 'theme',
+            flavors: [
+                {
+                    name: 'Liquid',
+                    value: 'liquid',
+                    path: 'theme-extension/liquid',
+                },
+            ],
+        },
+    ],
 };
 
 export { ThemeExtension as default };

package/dist/cli/services/generate/generate.d.ts

@@ -1,10 +1,10 @@
-import type { ExtensionFlavor, ExtensionTemplateType, InitialAppConfig } from '@/types';
-export declare function ensureExtensionDirectoryExists(name: string): Promise<string>;
-export interface InitExtensionOptions {
-    name: string;
-    app: InitialAppConfig;
-    directory: string;
-    type: ExtensionTemplateType;
-    flavor?: ExtensionFlavor;
-}
-export declare function initThemeExtension(options: InitExtensionOptions): Promise<void>;
+import type { ExtensionFlavor, ExtensionTemplateType, InitialAppConfig } from '@/types';
+export declare function ensureExtensionDirectoryExists(name: string): Promise<string>;
+export interface InitExtensionOptions {
+    name: string;
+    app: InitialAppConfig;
+    directory: string;
+    type: ExtensionTemplateType;
+    flavor?: ExtensionFlavor;
+}
+export declare function initThemeExtension(options: InitExtensionOptions): Promise<void>;

package/dist/cli/services/generate/generate.js

@@ -1,30 +1,30 @@
 import { Path, Filesystem, Git } from '@youcan/cli-kit';
 import { EXTENSION_CONFIG_FILENAME } from '../../../constants.js';
 
-async function ensureExtensionDirectoryExists(name) {
-    const dir = Path.join(Path.cwd(), 'extensions', name);
-    if (await Filesystem.exists(dir)) {
-        throw new Error(`The '${name}' already exists, choose a new name for your extension`);
-    }
-    await Filesystem.mkdir(dir);
-    return dir;
-}
-async function initThemeExtension(options) {
-    return Filesystem.tapIntoTmp(async (tmp) => {
-        const directory = Path.join(tmp, 'download');
-        await Filesystem.mkdir(directory);
-        await Git.clone({
-            url: options.type.url,
-            destination: directory,
-            shallow: true,
-        });
-        const flavorPath = Path.join(directory, options.flavor?.path || '');
-        if (!await Filesystem.exists(flavorPath)) {
-            throw new Error(`Extension flavor '${options.flavor?.name}' is unavailble`);
-        }
-        await Filesystem.move(flavorPath, options.directory, { overwrite: true });
-        await Filesystem.writeJsonFile(Path.join(options.directory, EXTENSION_CONFIG_FILENAME), { name: options.name, type: options.type.type });
-    });
+async function ensureExtensionDirectoryExists(name) {
+    const dir = Path.join(Path.cwd(), 'extensions', name);
+    if (await Filesystem.exists(dir)) {
+        throw new Error(`The '${name}' already exists, choose a new name for your extension`);
+    }
+    await Filesystem.mkdir(dir);
+    return dir;
+}
+async function initThemeExtension(options) {
+    return Filesystem.tapIntoTmp(async (tmp) => {
+        const directory = Path.join(tmp, 'download');
+        await Filesystem.mkdir(directory);
+        await Git.clone({
+            url: options.type.url,
+            destination: directory,
+            shallow: true,
+        });
+        const flavorPath = Path.join(directory, options.flavor?.path || '');
+        if (!await Filesystem.exists(flavorPath)) {
+            throw new Error(`Extension flavor '${options.flavor?.name}' is unavailble`);
+        }
+        await Filesystem.move(flavorPath, options.directory, { overwrite: true });
+        await Filesystem.writeJsonFile(Path.join(options.directory, EXTENSION_CONFIG_FILENAME), { name: options.name, type: options.type.type });
+    });
 }
 
 export { ensureExtensionDirectoryExists, initThemeExtension };

package/dist/constants.d.ts

@@ -1,5 +1,5 @@
-export declare const APP_CONFIG_FILENAME = "youcan.app.json";
-export declare const WEB_CONFIG_FILENAME = "youcan.web.json";
-export declare const EXTENSION_CONFIG_FILENAME = "youcan.extension.json";
-export declare const DEFAULT_WEBS_DIR = ".";
-export declare const DEFAULT_EXTENSIONS_DIR = "extensions/";
+export declare const APP_CONFIG_FILENAME = "youcan.app.json";
+export declare const WEB_CONFIG_FILENAME = "youcan.web.json";
+export declare const EXTENSION_CONFIG_FILENAME = "youcan.extension.json";
+export declare const DEFAULT_WEBS_DIR = ".";
+export declare const DEFAULT_EXTENSIONS_DIR = "extensions/";

package/dist/constants.js

@@ -1,7 +1,7 @@
-const APP_CONFIG_FILENAME = 'youcan.app.json';
-const WEB_CONFIG_FILENAME = 'youcan.web.json';
-const EXTENSION_CONFIG_FILENAME = 'youcan.extension.json';
-const DEFAULT_WEBS_DIR = '.';
+const APP_CONFIG_FILENAME = 'youcan.app.json';
+const WEB_CONFIG_FILENAME = 'youcan.web.json';
+const EXTENSION_CONFIG_FILENAME = 'youcan.extension.json';
+const DEFAULT_WEBS_DIR = '.';
 const DEFAULT_EXTENSIONS_DIR = 'extensions/';
 
 export { APP_CONFIG_FILENAME, DEFAULT_EXTENSIONS_DIR, DEFAULT_WEBS_DIR, EXTENSION_CONFIG_FILENAME, WEB_CONFIG_FILENAME };

package/dist/flags.d.ts

@@ -1,3 +1,3 @@
-export declare const APP_FLAGS: {
-    path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-};
+export declare const APP_FLAGS: {
+    path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+};

package/dist/flags.js

@@ -1,13 +1,13 @@
 import { Flags } from '@oclif/core';
 import { Path } from '@youcan/cli-kit';
 
-const APP_FLAGS = {
-    path: Flags.string({
-        env: 'YC_FLAG_PATH',
-        default: async () => Path.cwd(),
-        parse: async (input) => Path.resolve(input),
-        description: 'The path to your app directory.',
-    }),
+const APP_FLAGS = {
+    path: Flags.string({
+        env: 'YC_FLAG_PATH',
+        default: async () => Path.cwd(),
+        parse: async (input) => Path.resolve(input),
+        description: 'The path to your app directory.',
+    }),
 };
 
 export { APP_FLAGS };