vyriy 0.3.4 → 0.3.8

package/project-plan/create/create.js

@@ -6,111 +6,107 @@ const baseFeatures = [
     'eslint',
     'prettier',
     'jest',
+    'storybook',
 ];
 const presetFeatures = {
-    library: ['react', 'storybook'],
+    empty: [],
+    library: ['react'],
     api: [],
-    'react-csr': ['react', 'webpack'],
-    'react-ssr': ['react', 'webpack'],
-    'react-ssg': ['react', 'webpack'],
-    mfe: ['react', 'webpack'],
-    openmfe: ['react', 'webpack', 'openmfe'],
-    'mfe-bff': ['react', 'webpack', 'bff'],
-    'openmfe-bff': [
-        'react',
-        'webpack',
-        'openmfe',
-        'bff',
-    ],
+    csr: ['react', 'webpack'],
+    ssr: ['react', 'webpack'],
+    ssg: ['react', 'webpack'],
     fullstack: ['react', 'webpack'],
-    'aws-serverless': ['aws-cdk', 'lambda', 'dynamodb'],
-    empty: [],
+    mfe: ['react', 'webpack', 'openmfe'],
 };
 const packagePlans = {
+    empty: [],
     library: [{ name: 'ui', kind: 'ui', publishable: true }],
     api: [{ name: 'api', kind: 'api', publishable: false }],
-    'react-csr': [
-        { name: 'app', kind: 'core', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-    ],
-    'react-ssr': [
-        { name: 'app', kind: 'core', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'ssr', kind: 'ssr', publishable: false },
-    ],
-    'react-ssg': [
-        { name: 'app', kind: 'core', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'ssg', kind: 'ssg', publishable: false },
-        { name: 'content', kind: 'core', publishable: false },
-    ],
-    mfe: [
-        { name: 'mfe', kind: 'mfe', publishable: false },
+    csr: [
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
     ],
-    openmfe: [
-        { name: 'mfe', kind: 'mfe', publishable: false },
+    ssr: [
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'openmfe-contract', kind: 'contract', publishable: true },
+        { name: 'ssr', kind: 'app', publishable: false },
     ],
-    'mfe-bff': [
-        { name: 'mfe', kind: 'mfe', publishable: false },
+    ssg: [
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'bff', kind: 'bff', publishable: false },
-    ],
-    'openmfe-bff': [
-        { name: 'mfe', kind: 'mfe', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'bff', kind: 'bff', publishable: false },
-        { name: 'openmfe-contract', kind: 'contract', publishable: true },
+        { name: 'ssg', kind: 'app', publishable: false },
+        { name: 'content', kind: 'utils', publishable: false },
     ],
     fullstack: [
-        { name: 'app', kind: 'core', publishable: false },
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
         { name: 'api', kind: 'api', publishable: false },
     ],
-    'aws-serverless': [
+    mfe: [
+        { name: 'mfe', kind: 'app', publishable: false },
+        { name: 'ui', kind: 'ui', publishable: true },
         { name: 'api', kind: 'api', publishable: false },
-        { name: 'infrastructure', kind: 'core', publishable: false },
+        { name: 'openmfe-contract', kind: 'config', publishable: true },
     ],
-    empty: [],
 };
 const workspacePlans = {
+    empty: [],
     library: [],
     api: [{ name: 'api', kind: 'api' }],
-    'react-csr': [{ name: 'web', kind: 'web' }],
-    'react-ssr': [
-        { name: 'ssr', kind: 'ssr' },
-        { name: 'web', kind: 'web' },
-    ],
-    'react-ssg': [
-        { name: 'ssg', kind: 'ssg' },
-        { name: 'web', kind: 'web' },
+    csr: [{ name: 'web', kind: 'ui' }],
+    ssr: [
+        { name: 'ssr', kind: 'ui' },
+        { name: 'web', kind: 'ui' },
     ],
-    mfe: [{ name: 'mfe', kind: 'mfe' }],
-    openmfe: [
-        { name: 'mfe', kind: 'mfe' },
-        { name: 'openmfe', kind: 'openmfe' },
-    ],
-    'mfe-bff': [
-        { name: 'mfe', kind: 'mfe' },
-        { name: 'bff', kind: 'bff' },
-    ],
-    'openmfe-bff': [
-        { name: 'mfe', kind: 'mfe' },
-        { name: 'bff', kind: 'bff' },
-        { name: 'openmfe', kind: 'openmfe' },
+    ssg: [
+        { name: 'ssg', kind: 'ui' },
+        { name: 'web', kind: 'ui' },
     ],
     fullstack: [
-        { name: 'web', kind: 'web' },
+        { name: 'web', kind: 'ui' },
+        { name: 'api', kind: 'api' },
+    ],
+    mfe: [
+        { name: 'mfe', kind: 'ui' },
         { name: 'api', kind: 'api' },
     ],
-    'aws-serverless': [{ name: 'cdk', kind: 'cdk' }],
-    empty: [],
 };
 const uniqueFeatures = (features) => [...new Set(features)];
+const getApiRuntimeFromFeatures = (features) => features.includes('lambda') ? 'lambda' : 'docker';
+const awsInfrastructureFeatures = [
+    'aws-cdk',
+    'lambda',
+    'fargate',
+    's3',
+    'cloudfront',
+];
+const getApiWorkspaceKindFromFeatures = (features) => {
+    if (features.includes('lambda')) {
+        return 'lambda';
+    }
+    if (features.includes('fargate')) {
+        return 'fargate';
+    }
+    return 'api';
+};
+const createWorkspacePlans = ({ features, preset, }) => {
+    const apiWorkspaceKind = getApiWorkspaceKindFromFeatures(features);
+    const workspaces = workspacePlans[preset].map((workspacePlan) => workspacePlan.name === 'api'
+        ? {
+            ...workspacePlan,
+            kind: apiWorkspaceKind,
+        }
+        : workspacePlan);
+    if (features.some((feature) => awsInfrastructureFeatures.includes(feature))) {
+        return [
+            ...workspaces,
+            { name: 'stack', kind: 'stack' },
+        ];
+    }
+    return workspaces;
+};
 export const createProjectPlanFromPreset = ({ description, apiStyle, ciProvider, features = [], packageScope, preset, projectName, targetDirectory, }) => {
-    const api = createApiPlan({ preset, style: apiStyle });
+    const api = createApiPlan({ preset, runtime: getApiRuntimeFromFeatures(features), style: apiStyle });
     const apiFeatures = getFeaturesFromApiPlan(api);
     return {
         projectName,
@@ -126,7 +122,7 @@ export const createProjectPlanFromPreset = ({ description, apiStyle, ciProvider,
             ...features,
         ]),
         packages: [...packagePlans[preset]],
-        workspaces: [...workspacePlans[preset]],
+        workspaces: createWorkspacePlans({ features, preset }),
         ci: createCiPlan({ provider: ciProvider }),
         ...(api ? { api } : {}),
     };

package/project-plan/kind/kind.js

@@ -1,16 +1 @@
-export const getProjectKindFromPreset = (preset) => {
-    switch (preset) {
-        case 'react-csr':
-            return 'csr';
-        case 'react-ssr':
-            return 'ssr';
-        case 'react-ssg':
-            return 'ssg';
-        case 'openmfe':
-        case 'mfe-bff':
-        case 'openmfe-bff':
-            return 'mfe';
-        default:
-            return preset;
-    }
-};
+export const getProjectKindFromPreset = (preset) => preset;

package/project-plan/types.d.ts

@@ -1,24 +1,24 @@
-export type VyriyProjectKind = 'library' | 'api' | 'csr' | 'ssr' | 'ssg' | 'mfe' | 'fullstack' | 'aws-serverless' | 'empty';
-export type VyriyPreset = 'library' | 'api' | 'react-csr' | 'react-ssr' | 'react-ssg' | 'mfe' | 'openmfe' | 'mfe-bff' | 'openmfe-bff' | 'fullstack' | 'aws-serverless' | 'empty';
-export type VyriyFeature = 'typescript' | 'eslint' | 'prettier' | 'jest' | 'rest-api' | 'graphql-api' | 'react' | 'storybook' | 'webpack' | 'docker' | 'aws-cdk' | 'dynamodb' | 'lambda' | 'fargate' | 's3' | 'cloudfront' | 'openmfe' | 'bff';
+export type VyriyProjectKind = 'library' | 'api' | 'csr' | 'ssr' | 'ssg' | 'mfe' | 'fullstack' | 'empty';
+export type VyriyPreset = 'empty' | 'library' | 'api' | 'ssr' | 'ssg' | 'csr' | 'fullstack' | 'mfe';
+export type VyriyFeature = 'typescript' | 'eslint' | 'prettier' | 'jest' | 'rest-api' | 'graphql-api' | 'react' | 'storybook' | 'webpack' | 'docker' | 'aws-cdk' | 'apigateway' | 'lambda' | 'fargate' | 's3' | 'cloudfront' | 'openmfe';
 export type VyriyPackagePlan = {
     readonly name: string;
-    readonly kind: 'core' | 'ui' | 'api' | 'bff' | 'ssr' | 'ssg' | 'mfe' | 'contract';
+    readonly kind: 'core' | 'ui' | 'api' | 'services' | 'stack' | 'config' | 'utils' | 'components' | 'app';
     readonly publishable: boolean;
 };
 export type VyriyWorkspacePlan = {
     readonly name: string;
-    readonly kind: 'web' | 'api' | 'ssr' | 'ssg' | 'storybook' | 'bff' | 'mfe' | 'openmfe' | 'cdk';
+    readonly kind: 'api' | 'ui' | 'stack' | 'lambda' | 'fargate';
 };
 export type VyriyCiProvider = 'gitlab' | 'github';
-export type VyriyCiPipeline = 'install' | 'typecheck' | 'lint' | 'prettier' | 'test' | 'build' | 'storybook' | 'docker' | 'npm-publish' | 'aws-deploy';
+export type VyriyCiPipeline = 'install' | 'lint' | 'test' | 'build' | 'deploy' | 'smoke' | 'e2e';
 export type VyriyCiPlan = {
     readonly enabled: boolean;
     readonly providers: VyriyCiProvider[];
     readonly pipelines: VyriyCiPipeline[];
 };
-export type VyriyApiStyle = 'rest' | 'graphql' | 'mixed';
-export type VyriyApiRuntime = 'node' | 'lambda' | 'fargate';
+export type VyriyApiStyle = 'rest' | 'graphql';
+export type VyriyApiRuntime = 'docker' | 'lambda';
 export type VyriyApiPlan = {
     readonly enabled: boolean;
     readonly style: VyriyApiStyle;

package/prompts/project-plan/project-plan.js

@@ -2,30 +2,62 @@ import { stdin, stdout } from 'node:process';
 import { createInterface } from 'node:readline';
 import { createProjectPlanFromPreset, getDefaultApiStyleFromPreset, isApiPreset, } from '../../project-plan/index.js';
 const presets = [
+    'empty',
     'library',
     'api',
-    'react-csr',
-    'react-ssr',
-    'react-ssg',
-    'mfe',
-    'openmfe',
-    'mfe-bff',
-    'openmfe-bff',
+    'ssr',
+    'ssg',
+    'csr',
     'fullstack',
-    'aws-serverless',
-    'empty',
+    'mfe',
 ];
-const extraFeatures = [
-    'storybook',
+const presetDescriptions = {
+    empty: 'shared tooling without application code',
+    library: 'publishable React package for reusable UI',
+    api: 'REST or GraphQL backend API',
+    ssr: 'server-rendered React application',
+    ssg: 'build-time generated static React site',
+    csr: 'browser-rendered React application',
+    fullstack: 'React frontend with backend API',
+    mfe: 'OpenMFE widget with UI, API, SSR, and manifest',
+};
+const infrastructureOptions = ['docker', 'aws'];
+const infrastructureFeatureMap = {
+    docker: ['docker'],
+    aws: [
+        'aws-cdk',
+        'lambda',
+        'apigateway',
+    ],
+};
+const extraFeatureMap = {
+    docker: ['docker'],
+    'aws-api': [
+        'aws-cdk',
+        'lambda',
+        'apigateway',
+    ],
+    'aws-fargate': [
+        'aws-cdk',
+        'fargate',
+        'docker',
+    ],
+    'aws-static': [
+        'aws-cdk',
+        's3',
+        'cloudfront',
+    ],
+};
+const directFeatureInputs = [
     'docker',
     'aws-cdk',
-    'dynamodb',
+    'apigateway',
     'lambda',
     'fargate',
     's3',
     'cloudfront',
 ];
-const apiStyles = ['rest', 'graphql', 'mixed'];
+const apiStyles = ['rest', 'graphql'];
 const ciProviders = ['none', 'gitlab', 'github'];
 const createQuestion = (readline, output) => {
     const queuedLines = [];
@@ -64,10 +96,37 @@ const parsePreset = (value, defaultValue) => {
     }
     return presets.includes(normalizedValue) ? normalizedValue : defaultValue;
 };
-const parseFeatures = (value) => value
-    .split(',')
-    .map((feature) => feature.trim())
-    .filter((feature) => extraFeatures.includes(feature));
+const parseFeatures = (value) => [
+    ...new Set(value
+        .split(',')
+        .map((feature) => feature.trim())
+        .flatMap((feature) => extraFeatureMap[feature] ??
+        (directFeatureInputs.includes(feature)
+            ? [feature]
+            : []))),
+];
+const parseInfrastructure = (value, defaultValue) => {
+    const normalizedValue = value.trim().toLowerCase();
+    const numericValue = Number.parseInt(normalizedValue, 10);
+    if (Number.isInteger(numericValue) && infrastructureOptions[numericValue - 1]) {
+        return [...infrastructureFeatureMap[infrastructureOptions[numericValue - 1]]];
+    }
+    if (infrastructureOptions.includes(normalizedValue)) {
+        return [...infrastructureFeatureMap[normalizedValue]];
+    }
+    const legacyFeatures = parseFeatures(value);
+    return legacyFeatures.length > 0 ? legacyFeatures : [...infrastructureFeatureMap[defaultValue]];
+};
+const getDefaultInfrastructureInput = (features) => features?.some((feature) => [
+    'aws-cdk',
+    'lambda',
+    'apigateway',
+    'fargate',
+    's3',
+    'cloudfront',
+].includes(feature))
+    ? 'aws'
+    : 'docker';
 const parseApiStyle = (value, defaultValue) => {
     const normalizedValue = value.trim().toLowerCase();
     const numericValue = Number.parseInt(normalizedValue, 10);
@@ -96,12 +155,13 @@ export const askProjectPlan = async ({ defaults = {}, input = stdin, output = st
         const packageScope = await promptWithDefault(question, 'Package scope', defaults.packageScope ?? `@${projectName}`);
         const description = await promptWithDefault(question, 'Description', defaults.description ?? 'Calm cloud-ready application.');
         output.write('\nProject preset:\n');
-        presets.forEach((preset, index) => output.write(`  ${index + 1}. ${preset}\n`));
-        const presetAnswer = await promptWithDefault(question, 'Preset number or name', defaults.preset ?? 'react-ssr');
-        const preset = parsePreset(presetAnswer, defaults.preset ?? 'react-ssr');
+        presets.forEach((preset, index) => output.write(`  ${index + 1}. ${preset} - ${presetDescriptions[preset]}\n`));
+        const defaultPreset = defaults.preset ?? 'empty';
+        const presetAnswer = await promptWithDefault(question, 'Preset number or name', defaultPreset);
+        const preset = parsePreset(presetAnswer, defaultPreset);
         const defaultApiStyle = defaults.apiStyle ?? getDefaultApiStyleFromPreset(preset);
         const apiStyle = isApiPreset(preset)
-            ? parseApiStyle(await promptWithDefault(question, 'API style: 1. rest (@vyriy/router), 2. graphql, 3. mixed', defaultApiStyle), defaultApiStyle)
+            ? parseApiStyle(await promptWithDefault(question, 'API style:\n  1. rest (@vyriy/router),\n  2. graphql', defaultApiStyle), defaultApiStyle)
             : undefined;
         output.write('\nCI/CD provider:\n');
         output.write('  1. none\n');
@@ -109,10 +169,12 @@ export const askProjectPlan = async ({ defaults = {}, input = stdin, output = st
         output.write('  3. github\n');
         const defaultCiProvider = defaults.ciProvider ?? 'none';
         const ciProvider = parseCiProvider(await promptWithDefault(question, 'CI/CD provider number or name', defaultCiProvider), defaultCiProvider);
-        output.write('\nAdditional features, comma-separated:\n');
-        output.write(`  ${extraFeatures.join(', ')}\n`);
-        const featuresAnswer = await promptWithDefault(question, 'Features', defaults.features?.join(', ') ?? '');
-        const features = parseFeatures(featuresAnswer);
+        output.write('\nInfrastructure:\n');
+        output.write('  1. Docker\n');
+        output.write('  2. AWS\n');
+        const defaultInfrastructure = getDefaultInfrastructureInput(defaults.features);
+        const featuresAnswer = await promptWithDefault(question, 'Infrastructure number or name', defaultInfrastructure);
+        const features = parseInfrastructure(featuresAnswer, defaultInfrastructure);
         const plan = createProjectPlanFromPreset({
             projectName,
             targetDirectory,

package/shared/index.d.ts

@@ -1,5 +1,6 @@
 export * from './commandExists.js';
 export * from './execCommand.js';
 export * from './fileExists.js';
+export * from './runCommand.js';
 export * from './semver.js';
 export type * from './types.js';

package/shared/index.js

@@ -1,4 +1,5 @@
 export * from './commandExists.js';
 export * from './execCommand.js';
 export * from './fileExists.js';
+export * from './runCommand.js';
 export * from './semver.js';

package/shared/runCommand.d.ts

@@ -0,0 +1,9 @@
+import { RunCommand, RunCommandOptions } from './types.js';
+export declare class RunCommandError extends Error {
+    readonly args: readonly string[];
+    readonly command: string;
+    readonly cwd: string;
+    readonly exitCode: number | null;
+    constructor({ args, command, cwd }: RunCommandOptions, exitCode: number | null);
+}
+export declare const runCommand: RunCommand;

package/shared/runCommand.js

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process';
+import { env as processEnv } from 'node:process';
+export class RunCommandError extends Error {
+    args;
+    command;
+    cwd;
+    exitCode;
+    constructor({ args = [], command, cwd }, exitCode) {
+        super(`Command failed with exit code ${exitCode ?? 'unknown'}: ${command} ${args.join(' ')}`.trim());
+        this.name = 'RunCommandError';
+        this.args = args;
+        this.command = command;
+        this.cwd = cwd;
+        this.exitCode = exitCode;
+    }
+}
+export const runCommand = async (options) => {
+    const child = spawn(options.command, [...(options.args ?? [])], {
+        cwd: options.cwd,
+        env: options.env ?? processEnv,
+        shell: false,
+        stdio: 'inherit',
+    });
+    await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new RunCommandError(options, code));
+        });
+    });
+};

package/shared/types.d.ts

@@ -1,4 +1,11 @@
 export type ExecCommand = (command: string, args?: readonly string[]) => Promise<string>;
+export type RunCommandOptions = {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd: string;
+    readonly env?: Record<string, string | undefined>;
+};
+export type RunCommand = (options: RunCommandOptions) => Promise<void>;
 export type CommandExists = (command: string, options?: {
     readonly execCommand?: ExecCommand;
 }) => Promise<boolean>;