@aerogel/cli 0.0.0-next.0be1479064cfd43fb6eafa2552cb7f8775554d93

package/src/lib/Log.test.ts

@@ -0,0 +1,37 @@
+import { bold, hex } from 'chalk';
+import { describe, it } from 'vitest';
+
+import LogMock from '@/lib/Log.mock';
+
+import Log from './Log';
+
+const info = hex('#00ffff');
+
+describe('Log', () => {
+
+    it('renders markdown bold', () => {
+        // Act
+        Log.info('Foo **bar**');
+
+        // Assert
+        LogMock.expectLogged(info(`Foo ${bold('bar')}`));
+    });
+
+    it('renders multiline messages', () => {
+        // Act
+        Log.info(`
+            This is multiline,
+                but the indentation should be respected.
+
+            As well as the new lines.
+        `);
+
+        // Assert
+        LogMock.expectLogLength(4);
+        LogMock.expectLogged(info('This is multiline,'));
+        LogMock.expectLogged(info('    but the indentation should be respected.'));
+        LogMock.expectLogged(info(''));
+        LogMock.expectLogged(info('As well as the new lines.'));
+    });
+
+});

package/src/lib/Log.ts

@@ -0,0 +1,95 @@
+import { facade, stringMatchAll } from '@noeldemartin/utils';
+import { bold, hex } from 'chalk';
+import { clearLine, cursorTo } from 'readline';
+
+export class LogService {
+
+    protected renderInfo = hex('#00ffff');
+    protected renderSuccess = hex('#00ff00');
+    protected renderError = hex('#ff0000');
+
+    public async animate<T>(message: string, operation: () => Promise<T>): Promise<T> {
+        const updateStdout = (end: string = '', done: boolean = false) => {
+            const progress =
+                this.renderInfo(this.renderMarkdown(message) + (done ? '...' : '.'.repeat(frame % 4))) + end;
+
+            this.stdout(progress);
+        };
+
+        let frame = 0;
+
+        updateStdout();
+
+        const interval = setInterval(() => (frame++, updateStdout()), 1000);
+        const result = await operation();
+
+        clearInterval(interval);
+        updateStdout('\n', true);
+
+        return result;
+    }
+
+    public info(message: string): void {
+        this.log(this.renderMarkdown(message), this.renderInfo);
+    }
+
+    public error(message: string): void {
+        this.log(this.renderMarkdown(message), this.renderError);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    public fail<T = any>(message: string): T {
+        this.error(message);
+
+        process.exit(1);
+    }
+
+    public success(message: string): void {
+        this.log(this.renderMarkdown(message), this.renderSuccess);
+    }
+
+    protected renderMarkdown(message: string): string {
+        const matches = stringMatchAll<2>(message, /\*\*(.*)\*\*/g);
+
+        for (const match of matches) {
+            message = message.replace(match[0], bold(match[1]));
+        }
+
+        return message;
+    }
+
+    protected log(message: string, formatMessage?: (message: string) => string): void {
+        this.formatMessage(message).forEach((line) => {
+            this.logLine(formatMessage ? formatMessage(line) : line);
+        });
+    }
+
+    protected formatMessage(message: string): string[] {
+        if (message[0] === '\n') {
+            message = message.slice(1).trimEnd();
+
+            const lines = message.split('\n');
+            const firstLetter = message.trim()[0] ?? '';
+            const indentation = lines.find((line) => line.trim().length > 0)?.indexOf(firstLetter) ?? 0;
+
+            return lines.map((line) => line.slice(indentation));
+        }
+
+        return [message];
+    }
+
+    protected logLine(line: string): void {
+        // eslint-disable-next-line no-console
+        console.log(line);
+    }
+
+    protected stdout(message: string): void {
+        cursorTo(process.stdout, 0);
+        clearLine(process.stdout, 0);
+
+        process.stdout.write(message);
+    }
+
+}
+
+export default facade(new LogService());

package/src/lib/Shell.mock.ts

@@ -0,0 +1,20 @@
+import { expect } from 'vitest';
+import { facade } from '@noeldemartin/utils';
+
+import { ShellService } from './Shell';
+
+export class ShellServiceMock extends ShellService {
+
+    private history: string[] = [];
+
+    public async run(command: string): Promise<void> {
+        this.history.push(command);
+    }
+
+    public expectRan(command: string): void {
+        expect(this.history, `expected '${command}' command to have been executed`).toContain(command);
+    }
+
+}
+
+export default facade(new ShellServiceMock());

package/src/lib/Shell.ts

@@ -0,0 +1,28 @@
+import { exec } from 'child_process';
+import { facade } from '@noeldemartin/utils';
+
+export class ShellService {
+
+    private cwd: string | null = null;
+
+    public setWorkingDirectory(cwd: string): void {
+        this.cwd = cwd;
+    }
+
+    public async run(command: string): Promise<void> {
+        await new Promise<void>((resolve, reject) => {
+            exec(command, { cwd: this.cwd ?? undefined }, (error) => {
+                if (error) {
+                    reject(error);
+
+                    return;
+                }
+
+                resolve();
+            });
+        });
+    }
+
+}
+
+export default facade(new ShellService());

package/src/lib/Template.ts

@@ -0,0 +1,56 @@
+import { readFileSync } from 'fs';
+import { render } from 'mustache';
+import { toString } from '@noeldemartin/utils';
+
+import File from '@/lib/File';
+
+export default class Template {
+
+    public static instantiate(path: string, destination: string, replacements: Record<string, unknown>): string[] {
+        const template = new Template(path);
+
+        return template.instantiate(destination, replacements);
+    }
+
+    constructor(public path: string) {}
+
+    public instantiate(destination: string, replacements: Record<string, unknown> = {}): string[] {
+        const filenameReplacements = this.getFilenameReplacements(replacements);
+        const files: string[] = [];
+        destination = `${destination}/`.replace(/\/\//, '/');
+
+        for (const file of File.getFiles(this.path)) {
+            const relativePath = Object.entries(filenameReplacements).reduce(
+                (path, [match, replacement]) => path.replaceAll(match, replacement),
+                file.substring(this.path.length + 1),
+            );
+            const fileContents = readFileSync(file).toString();
+            const filePath =
+                destination + (relativePath.endsWith('.template') ? relativePath.slice(0, -9) : relativePath);
+
+            File.write(filePath, render(fileContents, replacements, undefined, ['<%', '%>']));
+            files.push(filePath);
+        }
+
+        return files;
+    }
+
+    protected getFilenameReplacements(
+        replacements: Record<string, unknown>,
+        prefix: string = '',
+    ): Record<string, string> {
+        return Object.entries(replacements).reduce((filenameReplacements, [key, value]) => {
+            if (typeof value === 'object') {
+                Object.assign(
+                    filenameReplacements,
+                    this.getFilenameReplacements(value as Record<string, unknown>, `${key}.`),
+                );
+            } else {
+                filenameReplacements[`[${prefix}${key}]`] = toString(value);
+            }
+
+            return filenameReplacements;
+        }, {} as Record<string, string>);
+    }
+
+}

package/src/lib/utils/app.ts

@@ -0,0 +1,15 @@
+import App from '@/lib/App';
+import File from '@/lib/File';
+
+export function app(): App {
+    // TODO parse app name
+    return new App('');
+}
+
+export function isLocalApp(): boolean {
+    return File.contains('package.json', 'file');
+}
+
+export function isLinkedLocalApp(): boolean {
+    return File.isSymlink('node_modules/@aerogel/core');
+}

package/src/lib/utils/edit.ts

@@ -0,0 +1,44 @@
+import { arrayFrom } from '@noeldemartin/utils';
+import type { Node, SyntaxKind } from 'ts-morph';
+
+export function editFiles(): boolean {
+    // TODO mock editor instead of relying on this for unit tests
+    return true;
+}
+
+export function findDescendant<T extends Node>(
+    node: Node | undefined,
+    options: {
+        guard?: (node: Node | undefined) => node is T;
+        validate?: (node: T) => boolean;
+        skip?: SyntaxKind | SyntaxKind[];
+    } = {},
+): T | undefined {
+    if (!node) {
+        return;
+    }
+
+    const guard = options.guard ?? (() => true);
+    const validate = options.validate ?? (() => true);
+    const skipKinds = arrayFrom(options.skip ?? []);
+
+    return node.forEachDescendant((descendant, traversal) => {
+        if (guard(descendant) && validate(descendant)) {
+            return descendant;
+        }
+
+        const descendantKind = descendant.getKind();
+
+        if (skipKinds.includes(descendantKind)) {
+            traversal.skip();
+        }
+    });
+}
+
+export function when<T extends Node>(node: Node | undefined, assertion: (node: Node) => node is T): T | undefined {
+    if (!node || !assertion(node)) {
+        return;
+    }
+
+    return node as T;
+}

package/src/lib/utils/format.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatCodeBlock } from './format';
+
+describe('Format utils', () => {
+
+    it('Formats code blocks', () => {
+        // Arrange
+        const raw = `
+
+            const foo = 'bar';
+
+            if (foo) {
+                doSomething();
+            }
+
+        `;
+        const formatted = [
+            'const foo = \'bar\';', //
+            '', //
+            'if (foo) {', //
+            '    doSomething();', //
+            '}', //
+        ].join('\n');
+
+        // Act
+        const actual = formatCodeBlock(raw);
+
+        // Assert
+        expect(actual).toEqual(formatted);
+    });
+
+});

package/src/lib/utils/format.ts

@@ -0,0 +1,38 @@
+export interface FormatCodeBlockOptions {
+    indent?: number;
+}
+
+export function formatCodeBlock(code: string, options: FormatCodeBlockOptions = {}): string {
+    const lines = code.split('\n');
+    const indent = options.indent ?? 0;
+    let originalIndent = 0;
+    let formatted = '';
+
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        const isEmptyLine = trimmedLine.length === 0;
+
+        if (formatted.length === 0) {
+            if (isEmptyLine) {
+                continue;
+            }
+
+            originalIndent = line.indexOf(trimmedLine[0] ?? '');
+            formatted += `${' '.repeat(indent)}${trimmedLine}\n`;
+
+            continue;
+        }
+
+        if (isEmptyLine) {
+            formatted += '\n';
+
+            continue;
+        }
+
+        const lineIndent = line.indexOf(trimmedLine[0] ?? '');
+
+        formatted += `${' '.repeat(indent + lineIndent - originalIndent)}${trimmedLine}\n`;
+    }
+
+    return formatted.trimEnd();
+}

package/src/lib/utils/paths.ts

@@ -0,0 +1,34 @@
+import { resolve } from 'path';
+import { stringMatch } from '@noeldemartin/utils';
+
+import File from '@/lib/File';
+import Log from '@/lib/Log';
+
+export function basePath(path: string = ''): string {
+    if (File.contains(resolve(__dirname, '../../../package.json'), '"name": "aerogel"')) {
+        return cliBasePath(path);
+    }
+
+    const packageJson = File.read(resolve(__dirname, '../../../../package.json'));
+    const matches = stringMatch<2>(packageJson ?? '', /"@aerogel\/cli": "file:(.*)\/aerogel-cli-[\d.]*\.tgz"/);
+    const cliPath = matches?.[1] ?? Log.fail<string>('Could not determine base path');
+
+    return resolve(cliPath, path);
+}
+
+export function cliBasePath(path: string = ''): string {
+    return resolve(__dirname, '../', path);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function packNotFound(packageName: string): any {
+    return Log.fail(`Could not find ${packageName} pack file, did you run 'npm pack'?`);
+}
+
+export function packagePackPath(packageName: string): string | null {
+    return File.getFiles(packagePath(packageName)).find((file) => file.endsWith('.tgz')) ?? null;
+}
+
+export function packagePath(packageName: string): string {
+    return basePath(`../${packageName}`);
+}

package/src/main.ts

@@ -0,0 +1,3 @@
+import CLI from './cli';
+
+export { CLI };

package/src/plugins/Plugin.ts

@@ -0,0 +1,125 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import type { ArrayLiteralExpression, ImportDeclarationStructure, OptionalKind, SourceFile } from 'ts-morph';
+
+import Log from '@/lib/Log';
+import Shell from '@/lib/Shell';
+import File from '@/lib/File';
+import { app, isLinkedLocalApp, isLocalApp } from '@/lib/utils/app';
+import { editFiles, findDescendant, when } from '@/lib/utils/edit';
+import { packNotFound, packagePackPath, packagePath } from '@/lib/utils/paths';
+import type { Editor } from '@/lib/Editor';
+
+export default abstract class Plugin {
+
+    public readonly name: string;
+
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    public async install(): Promise<void> {
+        this.assertNotInstalled();
+
+        await this.installDependencies();
+
+        if (editFiles()) {
+            const editor = app().edit();
+
+            await this.updateFiles(editor);
+            await editor.format();
+        }
+
+        Log.info(`Plugin ${this.name} installed!`);
+    }
+
+    protected assertNotInstalled(): void {
+        if (File.contains('package.json', `"${this.getNpmPackageName()}"`)) {
+            Log.fail(`${this.name} is already installed!`);
+        }
+    }
+
+    protected async installDependencies(): Promise<void> {
+        await Log.animate('Installing plugin dependencies', async () => {
+            await this.installNpmDependencies();
+        });
+    }
+
+    protected async updateFiles(editor: Editor): Promise<void> {
+        await this.updateBootstrapConfig(editor);
+    }
+
+    protected async installNpmDependencies(): Promise<void> {
+        if (isLinkedLocalApp()) {
+            await Shell.run(`npm install file:${packagePath(this.getLocalPackageName())}`);
+
+            return;
+        }
+
+        if (isLocalApp()) {
+            const packPath = packagePackPath(this.getLocalPackageName()) ?? packNotFound(this.getLocalPackageName());
+
+            await Shell.run(`npm install file:${packPath}`);
+
+            return;
+        }
+
+        await Shell.run(`npm install ${this.getNpmPackageName()}@next`);
+    }
+
+    protected async updateBootstrapConfig(editor: Editor): Promise<void> {
+        await Log.animate('Injecting plugin in bootstrap configuration', async () => {
+            const mainConfig = editor.requireSourceFile('src/main.ts');
+            const pluginsArray = this.getBootstrapPluginsDeclaration(mainConfig);
+
+            if (!pluginsArray) {
+                return Log.fail(`
+                    Could not find plugins array in bootstrap config, please add the following manually:
+
+                    ${this.getBootstrapConfig()}
+                `);
+            }
+
+            mainConfig.addImportDeclaration(this.getBootstrapImport());
+            pluginsArray.addElement(this.getBootstrapConfig());
+
+            await editor.save(mainConfig);
+        });
+    }
+
+    protected getBootstrapPluginsDeclaration(mainConfig: SourceFile): ArrayLiteralExpression | null {
+        const bootstrapAppCall = findDescendant(mainConfig, {
+            guard: Node.isCallExpression,
+            validate: (callExpression) => callExpression.getExpression().getText() === 'bootstrapApplication',
+            skip: SyntaxKind.ImportDeclaration,
+        });
+        const bootstrapOptions = bootstrapAppCall?.getArguments()[1];
+        const pluginsOption = when(bootstrapOptions, Node.isObjectLiteralExpression)?.getProperty('plugins');
+        const pluginsArray = when(pluginsOption, Node.isPropertyAssignment)?.getInitializer();
+
+        if (!Node.isArrayLiteralExpression(pluginsArray)) {
+            return null;
+        }
+
+        return pluginsArray;
+    }
+
+    protected getBootstrapImport(): OptionalKind<ImportDeclarationStructure> {
+        return {
+            defaultImport: this.name,
+            moduleSpecifier: `@aerogel/plugin-${this.name}`,
+        };
+    }
+
+    protected getNpmPackageName(): string {
+        return `@aerogel/${this.getLocalPackageName()}`;
+    }
+
+    protected getLocalPackageName(): string {
+        return `plugin-${this.name}`;
+    }
+
+    protected getBootstrapConfig(): string {
+        return `${this.name}()`;
+    }
+
+}

package/src/plugins/Solid.ts

@@ -0,0 +1,65 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import type { ArrayLiteralExpression, SourceFile } from 'ts-morph';
+
+import Plugin from '@/plugins/Plugin';
+import Shell from '@/lib/Shell';
+import Log from '@/lib/Log';
+import { findDescendant } from '@/lib/utils/edit';
+import { isLinkedLocalApp } from '@/lib/utils/app';
+import { packagePath } from '@/lib/utils/paths';
+import type { Editor } from '@/lib/Editor';
+
+export class Solid extends Plugin {
+
+    constructor() {
+        super('solid');
+    }
+
+    protected async updateFiles(editor: Editor): Promise<void> {
+        await this.updateTailwindConfig(editor);
+        await super.updateFiles(editor);
+    }
+
+    protected async installNpmDependencies(): Promise<void> {
+        await Shell.run('npm install soukai-solid@next');
+        await super.installNpmDependencies();
+    }
+
+    protected async updateTailwindConfig(editor: Editor): Promise<void> {
+        await Log.animate('Updating tailwind configuration', async () => {
+            const tailwindConfig = editor.requireSourceFile('tailwind.config.js');
+            const contentArray = this.getTailwindContentArray(tailwindConfig);
+            const contentValue = isLinkedLocalApp()
+                ? `'${packagePath('plugin-solid')}/dist/**/*.js'`
+                : '\'./node_modules/@aerogel/plugin-solid/dist/**/*.js\'';
+
+            if (!contentArray) {
+                return Log.fail(`
+                    Could not find content array in tailwind config, please add the following manually:
+
+                    ${contentValue}
+                `);
+            }
+
+            contentArray.addElement(contentValue);
+
+            await editor.save(tailwindConfig);
+        });
+    }
+
+    protected getTailwindContentArray(tailwindConfig: SourceFile): ArrayLiteralExpression | null {
+        const contentAssignment = findDescendant(tailwindConfig, {
+            guard: Node.isPropertyAssignment,
+            validate: (propertyAssignment) => propertyAssignment.getName() === 'content',
+            skip: SyntaxKind.JSDoc,
+        });
+        const contentArray = contentAssignment?.getInitializer();
+
+        if (!Node.isArrayLiteralExpression(contentArray)) {
+            return null;
+        }
+
+        return contentArray;
+    }
+
+}

package/src/plugins/Soukai.ts

@@ -0,0 +1,19 @@
+import Plugin from '@/plugins/Plugin';
+import Shell from '@/lib/Shell';
+
+export class Soukai extends Plugin {
+
+    constructor() {
+        super('soukai');
+    }
+
+    protected async installNpmDependencies(): Promise<void> {
+        await Shell.run('npm install soukai@next');
+        await super.installNpmDependencies();
+    }
+
+    protected getBootstrapConfig(): string {
+        return 'soukai({ models: import.meta.glob(\'@/models/*\', { eager: true }) })';
+    }
+
+}