@youcan/app 1.1.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 YouCan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli/commands/app/dev.d.ts

@@ -0,0 +1,5 @@
+import { AppCommand } from '@/util/theme-command';
+declare class Dev extends AppCommand {
+    run(): Promise<any>;
+}
+export default Dev;

package/dist/cli/commands/app/dev.js

@@ -0,0 +1,46 @@
+import { Session, Tasks, Http, Env, Filesystem, Path } from '@youcan/cli-kit';
+import { AppCommand } from '../../../util/theme-command.js';
+import { load } from '../../../util/app-loader.js';
+import { APP_CONFIG_FILENAME } from '../../../constants.js';
+import { bootExtensionWorker } from '../../services/dev/workers/index.js';
+
+class Dev extends AppCommand {
+    async run() {
+        const app = await load();
+        const session = await Session.authenticate(this);
+        await Tasks.run({ cmd: this }, [
+            {
+                title: 'Creating draft app..',
+                skip() {
+                    return app.config.id != null;
+                },
+                async task() {
+                    const res = await Http.post(`${Env.apiHostname()}/apps/draft/create`, {
+                        headers: { Authorization: `Bearer ${session.access_token}` },
+                        body: JSON.stringify({ name: app.config.name }),
+                    });
+                    app.config = {
+                        name: res.name,
+                        id: res.id,
+                        url: res.url,
+                        oauth: {
+                            scopes: res.scopes,
+                            client_id: res.client_id,
+                        },
+                    };
+                    await Filesystem.writeJsonFile(Path.join(app.root, APP_CONFIG_FILENAME), app.config);
+                },
+            },
+            {
+                title: 'Preparing dev workers..',
+                async task(ctx) {
+                    const promises = app.extensions.map(async (ext) => await bootExtensionWorker(ctx.cmd, app, ext));
+                    const workers = await Promise.all(promises);
+                    await Promise.all(workers.map(async (worker) => await worker.run()));
+                },
+            },
+        ]);
+    }
+}
+
+export { Dev as default };

package/dist/cli/commands/app/generate/extension.d.ts

@@ -0,0 +1,5 @@
+import { AppCommand } from '@/util/theme-command';
+declare class GenerateExtension extends AppCommand {
+    run(): Promise<any>;
+}
+export default GenerateExtension;

package/dist/cli/commands/app/generate/extension.js

@@ -0,0 +1,57 @@
+import { Path, Filesystem, String, Tasks } from '@youcan/cli-kit';
+import { AppCommand } from '../../../../util/theme-command.js';
+import extensions from '../../../services/generate/extensions/index.js';
+import { ensureExtensionDirectoryExists, initThemeExtension } from '../../../services/generate/generate.js';
+import { APP_CONFIG_FILENAME } from '../../../../constants.js';
+
+class GenerateExtension extends AppCommand {
+    async run() {
+        const filepath = Path.resolve(Path.cwd(), APP_CONFIG_FILENAME);
+        const app = await Filesystem.readJsonFile(filepath);
+        const { identifier } = await this.prompt({
+            name: 'identifier',
+            message: 'Extension type?',
+            type: 'select',
+            choices: extensions.map(ext => ({
+                title: ext.name,
+                value: ext.identifier,
+                description: ext.description,
+            })),
+        });
+        // TODO: prompt for extension type and flavor
+        const extension = extensions.find(ext => ext.identifier === identifier);
+        const type = extension.types[0];
+        const flavor = type.flavors[0];
+        const { name } = await this.prompt({
+            name: 'name',
+            message: 'Extension name?',
+            type: 'text',
+            initial: extension.name,
+            validate: prev => prev.length >= 3,
+            format: name => String.hyphenate(name),
+        });
+        await Tasks.run({}, [
+            {
+                title: 'Validating extension options..',
+                async task(ctx) {
+                    ctx.directory = await ensureExtensionDirectoryExists(name);
+                },
+            },
+            {
+                title: 'Initializing extension..',
+                async task(ctx) {
+                    await initThemeExtension({
+                        app,
+                        name,
+                        type,
+                        flavor,
+                        directory: ctx.directory,
+                    });
+                },
+            },
+        ]);
+        this.output.info(`Extension '${name}' successfully generated.`);
+    }
+}
+
+export { GenerateExtension as default };

package/dist/cli/services/dev/sync-extensions.d.ts

@@ -0,0 +1 @@
+export declare function syncExtensions(): Promise<void>;

package/dist/cli/services/dev/sync-extensions.js

@@ -0,0 +1,4 @@
+async function syncExtensions() {
+}
+
+export { syncExtensions };

package/dist/cli/services/dev/workers/index.d.ts

@@ -0,0 +1,3 @@
+import type { Cli } from '@youcan/cli-kit';
+import type { App, Extension } from '@/types';
+export declare function bootExtensionWorker(command: Cli.Command, app: App, extension: Extension): Promise<import("@/types").ExtensionWorker>;

package/dist/cli/services/dev/workers/index.js

@@ -0,0 +1,13 @@
+import ThemeExtensionWorker from './theme-extension-worker.js';
+
+const EXTENSION_WORKERS = {
+    theme: ThemeExtensionWorker,
+};
+async function bootExtensionWorker(command, app, extension) {
+    const Ctor = EXTENSION_WORKERS[extension.config.type];
+    const worker = new Ctor(command, app, extension);
+    await worker.boot();
+    return worker;
+}
+
+export { bootExtensionWorker };

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

@@ -0,0 +1,15 @@
+import type { Cli } from '@youcan/cli-kit';
+import type { App, Extension, ExtensionWorker } from '@/types';
+export default class ThemeExtensionWorker implements ExtensionWorker {
+    private command;
+    private app;
+    private extension;
+    FILE_TYPES: string[];
+    private EVENT_LOG_MAP;
+    private formatter;
+    constructor(command: Cli.Command, app: App, extension: Extension);
+    boot(): Promise<void>;
+    run(): Promise<void>;
+    private file;
+    private log;
+}

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

@@ -0,0 +1,117 @@
+import { Color, Session, Http, Env, Path, Filesystem, Crypto, Form } from '@youcan/cli-kit';
+
+class ThemeExtensionWorker {
+    command;
+    app;
+    extension;
+    FILE_TYPES = [
+        'assets',
+        'locales',
+        'snippets',
+        'blocks',
+    ];
+    EVENT_LOG_MAP = {
+        error: () => Color.bold().red('[error]'),
+        add: () => Color.bold().green('[created]'),
+        change: () => Color.bold().blue('[updated]'),
+        unlink: () => Color.bold().yellow('[deleted]'),
+    };
+    formatter = Intl.NumberFormat('en', {
+        unitDisplay: 'narrow',
+        notation: 'compact',
+        style: 'unit',
+        unit: 'byte',
+    });
+    constructor(command, app, extension) {
+        this.command = command;
+        this.app = app;
+        this.extension = extension;
+    }
+    async boot() {
+        const session = await Session.authenticate(this.command);
+        try {
+            const res = await Http.post(`${Env.apiHostname()}/apps/draft/${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;
+            for (const type of Object.keys(this.extension.metadata)) {
+                const descriptors = this.extension.metadata[type];
+                const directory = Path.resolve(this.extension.root, type);
+                const present = await Filesystem.readdir(Path.resolve(directory));
+                present.filter(f => !descriptors.find(d => d.file_name === f))
+                    .forEach(async (file) => await this.file('put', type, file));
+                descriptors.forEach(async (descriptor) => {
+                    const path = Path.resolve(directory, descriptor.file_name);
+                    if (!(await Filesystem.exists(path))) {
+                        return await this.file('del', type, descriptor.file_name);
+                    }
+                    const buff = await Filesystem.readFile(path);
+                    if (Crypto.sha1(buff) !== descriptor.hash) {
+                        await this.file('put', type, descriptor.file_name);
+                    }
+                });
+            }
+        }
+        catch (err) {
+            this.command.error(err);
+        }
+    }
+    async run() {
+        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,
+            },
+        });
+        watcher.on('all', async (event, path, stat) => {
+            try {
+                if (!['add', 'change', 'unlink'].includes(event)) {
+                    return;
+                }
+                const start = new Date().getTime();
+                const [filetype, filename] = [
+                    Path.basename(Path.dirname(path)),
+                    Path.basename(path),
+                ];
+                let size = 0;
+                switch (event) {
+                    case 'add':
+                    case 'change':
+                        size = (await this.file('put', filetype, filename)).size;
+                        break;
+                    case 'unlink':
+                        size = (await this.file('del', filetype, filename)).size;
+                        break;
+                }
+                this.log(event, Path.join(filetype, filename), this.formatter.format(stat.size), new Date().getTime() - start);
+            }
+            catch (err) {
+                this.log('error', path);
+                this.command.error(err);
+            }
+        });
+    }
+    async file(op, type, name) {
+        const path = Path.resolve(this.extension.root, type, name);
+        return await Http.post(`${Env.apiHostname()}/apps/draft/${this.app.config.id}/extensions/${this.extension.id}/file`, {
+            body: Form.convert({
+                file_name: name,
+                file_type: type,
+                file_operation: op,
+                file_content: await Form.file(path),
+            }),
+        });
+    }
+    log(event, path, size, time) {
+        const tag = this.EVENT_LOG_MAP[event]();
+        `${tag} ${Color.underline().white(path)}`;
+        this.command.log(`${tag} ${Color.underline().white(path)} - ${size} | ${time}ms \n`);
+    }
+}
+
+export { ThemeExtensionWorker as default };

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

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

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

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

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

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

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

@@ -0,0 +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',
+                },
+            ],
+        },
+    ],
+};
+
+export { ThemeExtension as default };

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

@@ -0,0 +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>;

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

@@ -0,0 +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 });
+    });
+}
+
+export { ensureExtensionDirectoryExists, initThemeExtension };

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const APP_CONFIG_FILENAME = "youcan.app.json";
+export declare const EXTENSION_CONFIG_FILENAME = "youcan.extension.json";
+export declare const DEFAULT_EXTENSIONS_DIR = "extensions/";

package/dist/constants.js

@@ -0,0 +1,5 @@
+const APP_CONFIG_FILENAME = 'youcan.app.json';
+const EXTENSION_CONFIG_FILENAME = 'youcan.extension.json';
+const DEFAULT_EXTENSIONS_DIR = 'extensions/';
+
+export { APP_CONFIG_FILENAME, DEFAULT_EXTENSIONS_DIR, EXTENSION_CONFIG_FILENAME };

package/dist/flags.d.ts

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

package/dist/flags.js

@@ -0,0 +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.',
+    }),
+};
+
+export { APP_FLAGS };

package/dist/types.d.ts

@@ -0,0 +1,63 @@
+import type { Cli } from '@youcan/cli-kit';
+export interface InitialAppConfig {
+    [key: string]: unknown;
+    name: string;
+}
+export interface ExtensionWorkerConstructor<T extends Extension = Extension> {
+    new (command: Cli.Command, app: App, extension: T): ExtensionWorker;
+}
+export interface ExtensionWorker {
+    run(): Promise<void>;
+    boot(): Promise<void>;
+}
+export type AppConfig = {
+    id: string;
+    url: string;
+    oauth: {
+        client_id: string;
+        scopes: string[];
+    };
+} & InitialAppConfig;
+export interface ExtensionConfig {
+    [key: string]: unknown;
+    type: string;
+    name: string;
+}
+export interface ExtensionFlavor {
+    name: string;
+    path?: string;
+    value: 'liquid';
+}
+export interface ExtensionTemplateType {
+    url: string;
+    type: string;
+    flavors: ExtensionFlavor[];
+}
+export interface ExtensionTemplate {
+    identifier: string;
+    name: string;
+    description: string;
+    types: ExtensionTemplateType[];
+}
+export interface Extension {
+    id?: string;
+    metadata?: ExtensionMetadata;
+    root: string;
+    config: ExtensionConfig;
+}
+export interface App {
+    root: string;
+    config: AppConfig;
+    extensions: Extension[];
+}
+export interface ExtensionFileDescriptor {
+    id: string;
+    type: string;
+    name: string;
+    file_name: string;
+    size: number;
+    hash: string;
+}
+export interface ExtensionMetadata {
+    [key: string]: ExtensionFileDescriptor[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+

package/dist/util/app-loader.d.ts

@@ -0,0 +1,2 @@
+import type { App } from '@/types';
+export declare function load(): Promise<App>;

package/dist/util/app-loader.js

@@ -0,0 +1,27 @@
+import { Path, Filesystem } from '@youcan/cli-kit';
+import { APP_CONFIG_FILENAME, DEFAULT_EXTENSIONS_DIR, EXTENSION_CONFIG_FILENAME } from '../constants.js';
+
+async function load() {
+    const path = Path.resolve(Path.cwd(), APP_CONFIG_FILENAME);
+    if (!await Filesystem.exists) {
+        throw new Error(`app config not found at ${path}`);
+    }
+    const config = await Filesystem.readJsonFile(path);
+    const app = {
+        config,
+        extensions: [],
+        root: Path.cwd(),
+    };
+    const pattern = Path.join(app.root, `${DEFAULT_EXTENSIONS_DIR}/*`, EXTENSION_CONFIG_FILENAME);
+    const paths = await Filesystem.glob(pattern);
+    const promises = paths.map(async (p) => {
+        return {
+            root: Path.dirname(p),
+            config: await Filesystem.readJsonFile(p),
+        };
+    });
+    app.extensions = await Promise.all(promises);
+    return app;
+}
+
+export { load };

package/dist/util/theme-command.d.ts

@@ -0,0 +1,3 @@
+import { Cli } from '@youcan/cli-kit';
+export declare abstract class AppCommand extends Cli.Command {
+}

package/dist/util/theme-command.js

@@ -0,0 +1,6 @@
+import { Cli } from '@youcan/cli-kit';
+
+class AppCommand extends Cli.Command {
+}
+
+export { AppCommand };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@youcan/app",
+  "type": "module",
+  "version": "1.1.0-beta.2",
+  "description": "OCLIF plugin for building apps",
+  "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
+  "license": "MIT",
+  "keywords": [
+    "youcan",
+    "youcan-cli",
+    "youcan-app"
+  ],
+  "files": [
+    "dist",
+    "oclif.manifest.json"
+  ],
+  "dependencies": {
+    "@oclif/core": "^2.15.0",
+    "@youcan/cli-kit": "1.1.0-beta.2"
+  },
+  "devDependencies": {
+    "@oclif/plugin-legacy": "^1.3.0",
+    "@types/node": "^18.18.0",
+    "shx": "^0.3.4"
+  },
+  "oclif": {
+    "commands": "./dist/cli/commands"
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && tsc --noEmit && rollup --config rollup.config.js",
+    "dev": "shx rm -rf dist && rollup --config rollup.config.js --watch",
+    "release": "pnpm publish --access public",
+    "type-check": "tsc --noEmit"
+  }
+}