vovk-cli 0.0.1-draft.99 → 0.0.3

package/dist/getProjectInfo/getConfig/getTemplateDefs.mjs

@@ -0,0 +1,168 @@
+export var BuiltInTemplateName;
+(function (BuiltInTemplateName) {
+    // ts/js
+    BuiltInTemplateName["tsBase"] = "tsBase";
+    BuiltInTemplateName["jsBase"] = "jsBase";
+    BuiltInTemplateName["ts"] = "ts";
+    BuiltInTemplateName["js"] = "js";
+    // schema
+    BuiltInTemplateName["schemaTs"] = "schemaTs";
+    BuiltInTemplateName["schemaJs"] = "schemaJs";
+    BuiltInTemplateName["schemaJson"] = "schemaJson";
+    // openapi
+    BuiltInTemplateName["openapiTs"] = "openapiTs";
+    BuiltInTemplateName["openapiJs"] = "openapiJs";
+    BuiltInTemplateName["openapiJson"] = "openapiJson";
+    // misc
+    BuiltInTemplateName["readme"] = "readme";
+    BuiltInTemplateName["packageJson"] = "packageJson";
+    BuiltInTemplateName["mixins"] = "mixins";
+    // other languages (packages installed separately)
+    BuiltInTemplateName["rsSrc"] = "rsSrc";
+    BuiltInTemplateName["rsPkg"] = "rsPkg";
+    BuiltInTemplateName["rsReadme"] = "rsReadme";
+    BuiltInTemplateName["rs"] = "rs";
+    BuiltInTemplateName["pySrc"] = "pySrc";
+    BuiltInTemplateName["pyPkg"] = "pyPkg";
+    BuiltInTemplateName["pyReadme"] = "pyReadme";
+    BuiltInTemplateName["py"] = "py";
+})(BuiltInTemplateName || (BuiltInTemplateName = {}));
+export function getTemplateDefs(userTemplateDefs = {}) {
+    const defs = {};
+    const builtInDefs = {
+        [BuiltInTemplateName.openapiTs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.openapiTs}/`,
+            requires: {
+                [BuiltInTemplateName.openapiJson]: './',
+            },
+        },
+        [BuiltInTemplateName.openapiJs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.openapiJs}/`,
+            requires: {
+                [BuiltInTemplateName.openapiJson]: './',
+            },
+        },
+        [BuiltInTemplateName.openapiJson]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.openapiJson}/`,
+        },
+        [BuiltInTemplateName.tsBase]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.tsBase}/`,
+            requires: {
+                [BuiltInTemplateName.schemaTs]: './',
+                [BuiltInTemplateName.mixins]: './', // used conditionally if OpenAPI mixins are used
+            },
+        },
+        [BuiltInTemplateName.jsBase]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.jsBase}/`,
+            requires: {
+                [BuiltInTemplateName.schemaJs]: './',
+                [BuiltInTemplateName.mixins]: './', // used conditionally if OpenAPI mixins are used
+            },
+        },
+        [BuiltInTemplateName.ts]: {
+            requires: {
+                [BuiltInTemplateName.tsBase]: './',
+                [BuiltInTemplateName.openapiTs]: './',
+            },
+        },
+        [BuiltInTemplateName.js]: {
+            requires: {
+                [BuiltInTemplateName.jsBase]: './',
+                [BuiltInTemplateName.openapiJs]: './',
+            },
+        },
+        [BuiltInTemplateName.schemaTs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaTs}/`,
+        },
+        [BuiltInTemplateName.schemaJs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaJs}/`,
+        },
+        [BuiltInTemplateName.schemaJson]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaJson}/`,
+        },
+        [BuiltInTemplateName.readme]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.readme}/`,
+        },
+        [BuiltInTemplateName.packageJson]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.packageJson}/`,
+        },
+        [BuiltInTemplateName.mixins]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.mixins}/`,
+        },
+        [BuiltInTemplateName.rsSrc]: {
+            templatePath: `vovk-rust/client-templates/${BuiltInTemplateName.rsSrc}/`,
+            requires: {
+                [BuiltInTemplateName.schemaJson]: './',
+            },
+        },
+        [BuiltInTemplateName.rsPkg]: {
+            templatePath: `vovk-rust/client-templates/${BuiltInTemplateName.rsPkg}/`,
+        },
+        [BuiltInTemplateName.rsReadme]: {
+            templatePath: `vovk-rust/client-templates/${BuiltInTemplateName.rsReadme}/`,
+        },
+        [BuiltInTemplateName.rs]: {
+            composedClient: {
+                outDir: 'dist_rust',
+            },
+            requires: {
+                [BuiltInTemplateName.rsSrc]: './src/',
+                [BuiltInTemplateName.rsPkg]: './',
+                [BuiltInTemplateName.rsReadme]: './',
+            },
+        },
+        [BuiltInTemplateName.pySrc]: {
+            templatePath: `vovk-python/client-templates/${BuiltInTemplateName.pySrc}/`,
+            requires: {
+                [BuiltInTemplateName.schemaJson]: './',
+            },
+        },
+        [BuiltInTemplateName.pyPkg]: {
+            templatePath: `vovk-python/client-templates/${BuiltInTemplateName.pyPkg}/`,
+        },
+        [BuiltInTemplateName.pyReadme]: {
+            templatePath: `vovk-python/client-templates/${BuiltInTemplateName.pyReadme}/`,
+        },
+        [BuiltInTemplateName.py]: {
+            composedClient: {
+                outDir: 'dist_python',
+            },
+            requires: {
+                [BuiltInTemplateName.pySrc]: './src/[package_name]/',
+                [BuiltInTemplateName.pyPkg]: './',
+                [BuiltInTemplateName.pyReadme]: './',
+            },
+        },
+    };
+    for (const [name, templateDef] of Object.entries(userTemplateDefs)) {
+        if ('extends' in templateDef) {
+            if (templateDef.extends) {
+                const builtIn = builtInDefs[templateDef.extends];
+                if (!builtIn) {
+                    throw new Error(`Unknown template extends: ${templateDef.extends}`);
+                }
+                defs[name] = {
+                    ...builtIn,
+                    ...templateDef,
+                    composedClient: {
+                        ...builtIn.composedClient,
+                        ...templateDef.composedClient,
+                    },
+                    segmentedClient: {
+                        ...builtIn.segmentedClient,
+                        ...templateDef.segmentedClient,
+                    },
+                    outputConfig: {
+                        ...builtIn.outputConfig,
+                        ...templateDef.outputConfig,
+                    },
+                    // 'requires' and other props will be overridden
+                };
+            }
+        }
+        else {
+            defs[name] = templateDef;
+        }
+    }
+    return { ...builtInDefs, ...defs };
+}

package/dist/getProjectInfo/getConfig/getUserConfig.d.mts

@@ -0,0 +1,9 @@
+import type { VovkConfig } from 'vovk';
+export declare function getUserConfig({ configPath: givenConfigPath, cwd, }: {
+    configPath?: string;
+    cwd: string;
+}): Promise<{
+    userConfig: VovkConfig | null;
+    configAbsolutePaths: string[];
+    error?: Error;
+}>;

package/dist/getProjectInfo/getConfig/getUserConfig.mjs

@@ -0,0 +1,142 @@
+import { pathToFileURL } from 'node:url';
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, extname } from 'node:path';
+import vm from 'node:vm';
+import { getConfigAbsolutePaths } from './getConfigAbsolutePaths.mjs';
+const isVMModulesEnabled = typeof vm.SourceTextModule !== 'undefined';
+export async function getUserConfig({ configPath: givenConfigPath, cwd, }) {
+    const configAbsolutePaths = await getConfigAbsolutePaths({ configPath: givenConfigPath, cwd });
+    if (!configAbsolutePaths.length) {
+        return { userConfig: null, configAbsolutePaths };
+    }
+    const configPath = configAbsolutePaths[0];
+    let userConfig;
+    let lastError;
+    const loaders = await getLoadersForExtension(configPath);
+    for (const loader of loaders) {
+        try {
+            userConfig = await loader();
+            return { userConfig, configAbsolutePaths };
+        }
+        catch (e) {
+            lastError = e;
+        }
+    }
+    return { userConfig: null, configAbsolutePaths, error: lastError };
+}
+async function getLoadersForExtension(configPath) {
+    const ext = extname(configPath).toLowerCase();
+    const code = await readFile(configPath, 'utf-8');
+    const hasDynamicImport = /\bimport\s*\(/.test(code);
+    // If config has dynamic imports and flag is not enabled, skip VM loaders entirely
+    const canUseVM = isVMModulesEnabled || !hasDynamicImport;
+    switch (ext) {
+        case '.mjs':
+            return canUseVM
+                ? [() => importWithVMModule(configPath, code), () => importWithCacheBuster(configPath)]
+                : [() => importWithCacheBuster(configPath)];
+        case '.cjs':
+            return canUseVM
+                ? [() => importWithVMCommonJS(configPath, code), () => importWithCacheBuster(configPath)]
+                : [() => importWithCacheBuster(configPath)];
+        default:
+            return canUseVM
+                ? [
+                    () => importWithVMCommonJS(configPath, code),
+                    () => importWithVMModule(configPath, code),
+                    () => importWithCacheBuster(configPath),
+                ]
+                : [() => importWithCacheBuster(configPath)];
+    }
+}
+function createDynamicImportHandler(context) {
+    return async (specifier) => {
+        const imported = await import(specifier);
+        const exportNames = Object.keys(imported);
+        const syntheticModule = new vm.SyntheticModule(exportNames, function () {
+            for (const name of exportNames) {
+                this.setExport(name, imported[name]);
+            }
+        }, { context, identifier: specifier });
+        await syntheticModule.link(() => {
+            throw new Error('Nested linking not supported');
+        });
+        await syntheticModule.evaluate();
+        return syntheticModule;
+    };
+}
+async function importWithVMCommonJS(configPath, code) {
+    const require = createRequire(configPath);
+    const moduleObj = { exports: {} };
+    const contextObject = {
+        module: moduleObj,
+        exports: moduleObj.exports,
+        require,
+        __filename: configPath,
+        __dirname: dirname(configPath),
+        console,
+        process,
+        Buffer,
+        URL,
+        URLSearchParams,
+        setTimeout,
+        setInterval,
+        setImmediate,
+        clearTimeout,
+        clearInterval,
+        clearImmediate,
+    };
+    const context = vm.createContext(contextObject);
+    const script = new vm.Script(code, {
+        filename: configPath,
+        importModuleDynamically: createDynamicImportHandler(context),
+    });
+    script.runInContext(context);
+    return moduleObj.exports;
+}
+async function importWithVMModule(configPath, code) {
+    if (!isVMModulesEnabled) {
+        throw new Error('vm.SourceTextModule not available');
+    }
+    const configUrl = pathToFileURL(configPath).href;
+    const context = vm.createContext({
+        console,
+        process,
+        Buffer,
+        URL,
+        URLSearchParams,
+        setTimeout,
+        setInterval,
+        setImmediate,
+        clearTimeout,
+        clearInterval,
+        clearImmediate,
+    });
+    const module = new vm.SourceTextModule(code, {
+        context,
+        identifier: configUrl,
+        initializeImportMeta(meta) {
+            meta.url = configUrl;
+        },
+        importModuleDynamically: createDynamicImportHandler(context),
+    });
+    await module.link(async (specifier) => {
+        const imported = await import(specifier);
+        const exportNames = Object.keys(imported);
+        const syntheticModule = new vm.SyntheticModule(exportNames, function () {
+            for (const name of exportNames) {
+                this.setExport(name, imported[name]);
+            }
+        }, { context, identifier: specifier });
+        return syntheticModule;
+    });
+    await module.evaluate();
+    return module.namespace.default;
+}
+async function importWithCacheBuster(configPath) {
+    const cacheBuster = Date.now();
+    const configPathUrl = pathToFileURL(configPath).href;
+    const { default: userConfig } = (await import(`${configPathUrl}?cache=${cacheBuster}`));
+    return userConfig;
+}

package/dist/getProjectInfo/getConfig/index.d.mts

@@ -0,0 +1,15 @@
+import type { VovkConfig } from 'vovk';
+import { type VovkStrictConfig } from 'vovk/internal';
+import type { LogLevelNames } from 'loglevel';
+import { getLogger } from '../../utils/getLogger.mjs';
+export declare function getConfig({ configPath, cwd, logLevel, }: {
+    configPath?: string;
+    cwd: string;
+    logLevel?: LogLevelNames;
+}): Promise<{
+    config: VovkStrictConfig;
+    srcRoot: string | null;
+    configAbsolutePaths: string[];
+    userConfig: VovkConfig | null;
+    log: ReturnType<typeof getLogger>;
+}>;

package/dist/getProjectInfo/getConfig/index.mjs

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import { VovkSchemaIdEnum } from 'vovk/internal';
+import { getLogger } from '../../utils/getLogger.mjs';
+import { getUserConfig } from './getUserConfig.mjs';
+import { getRelativeSrcRoot } from './getRelativeSrcRoot.mjs';
+import { getTemplateDefs, BuiltInTemplateName } from './getTemplateDefs.mjs';
+import { normalizeOpenAPIMixin } from '../../utils/normalizeOpenAPIMixin.mjs';
+import { chalkHighlightThing } from '../../utils/chalkHighlightThing.mjs';
+export async function getConfig({ configPath, cwd, logLevel, }) {
+    const { configAbsolutePaths, error, userConfig } = await getUserConfig({
+        configPath,
+        cwd,
+    });
+    const conf = userConfig ?? {};
+    logLevel = logLevel ?? conf.logLevel ?? 'info';
+    const log = getLogger(logLevel);
+    const env = process.env;
+    const clientTemplateDefs = getTemplateDefs(conf.clientTemplateDefs);
+    const srcRoot = await getRelativeSrcRoot({ cwd });
+    const config = {
+        $schema: VovkSchemaIdEnum.CONFIG,
+        clientTemplateDefs,
+        exposeConfigKeys: [],
+        composedClient: {
+            ...conf.composedClient,
+            enabled: conf.composedClient?.enabled ?? true,
+            fromTemplates: conf.composedClient?.fromTemplates ?? [BuiltInTemplateName.js],
+            outDir: conf.composedClient?.outDir ?? './node_modules/.vovk-client',
+            prettifyClient: conf.composedClient?.prettifyClient ?? false,
+        },
+        segmentedClient: {
+            ...conf.segmentedClient,
+            enabled: conf.segmentedClient?.enabled ?? false,
+            fromTemplates: conf.segmentedClient?.fromTemplates ?? ['ts'],
+            outDir: conf.segmentedClient?.outDir ?? path.join(srcRoot ?? '.', 'client'),
+            prettifyClient: conf.segmentedClient?.prettifyClient ?? true,
+        },
+        bundle: {
+            prebundleOutDir: conf.bundle?.prebundleOutDir ?? 'tmp_prebundle',
+            keepPrebundleDir: conf.bundle?.keepPrebundleDir ?? false,
+            outDir: conf.bundle?.outDir ?? 'dist',
+            requires: {
+                [BuiltInTemplateName.readme]: '.',
+                [BuiltInTemplateName.packageJson]: '.',
+            },
+            outputConfig: {},
+            build: conf.bundle?.build ??
+                (() => {
+                    throw new Error('No bundle.build function specified');
+                }),
+            ...conf.bundle,
+        },
+        modulesDir: conf.modulesDir ?? path.join(srcRoot ?? '.', 'modules'),
+        schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
+        rootEntry: env.VOVK_ROOT_ENTRY ?? conf.rootEntry ?? 'api',
+        rootSegmentModulesDirName: conf.rootSegmentModulesDirName ?? '',
+        logLevel,
+        devHttps: conf.devHttps ?? false,
+        moduleTemplates: {
+            service: 'vovk-cli/module-templates/type/service.ts.ejs',
+            controller: 'vovk-cli/module-templates/type/controller.ts.ejs',
+            ...conf.moduleTemplates,
+        },
+        libs: conf.libs ?? {},
+        outputConfig: {
+            ...conf.outputConfig,
+            origin: (env.VOVK_ORIGIN ?? conf?.outputConfig?.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
+            segments: Object.fromEntries(await Promise.all(Object.entries(conf.outputConfig?.segments ?? {}).map(async ([key, value]) => [
+                key,
+                {
+                    ...value,
+                    openAPIMixin: value.openAPIMixin
+                        ? await normalizeOpenAPIMixin({ mixinModule: value.openAPIMixin, log, cwd })
+                        : undefined,
+                },
+            ]))),
+        },
+    };
+    if (typeof conf.exposeConfigKeys === 'undefined') {
+        config.exposeConfigKeys = ['libs', 'rootEntry'];
+    }
+    else if (conf.exposeConfigKeys === true) {
+        config.exposeConfigKeys = Object.keys(config);
+    }
+    else if (Array.isArray(conf.exposeConfigKeys)) {
+        config.exposeConfigKeys = conf.exposeConfigKeys;
+    } // else it's false and exposeConfigKeys already is []
+    if (!userConfig) {
+        log.warn(`Unable to load config at ${chalkHighlightThing(`${cwd}/`)}. Using default values. ${error ?? ''}`);
+    }
+    return { config, srcRoot, configAbsolutePaths, userConfig, log };
+}

package/dist/getProjectInfo/getMetaSchema.d.mts

@@ -0,0 +1,4 @@
+import { type VovkStrictConfig, type VovkMetaSchema } from 'vovk/internal';
+export declare function getMetaSchema({ config }: {
+    config: VovkStrictConfig;
+}): VovkMetaSchema;

package/dist/getProjectInfo/getMetaSchema.mjs

@@ -0,0 +1,12 @@
+import { VovkSchemaIdEnum } from 'vovk/internal';
+import pick from 'lodash/pick.js';
+export function getMetaSchema({ config }) {
+    return {
+        $schema: VovkSchemaIdEnum.META,
+        config: config
+            ? pick(config, [...config.exposeConfigKeys, '$schema'])
+            : {
+                $schema: VovkSchemaIdEnum.CONFIG,
+            },
+    };
+}

package/dist/getProjectInfo/index.d.mts

@@ -1,27 +1,23 @@
+import type { LogLevelNames } from 'loglevel';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?: {
+export declare function getProjectInfo({ port: givenPort, cwd, configPath, srcRootRequired, logLevel, }?: {
     port?: number;
-    clientOutDir?: string;
     cwd?: string;
+    configPath?: string;
+    srcRootRequired?: boolean;
+    logLevel?: LogLevelNames;
 }): Promise<{
     cwd: string;
     port: string;
     apiRoot: string;
-    apiDir: string;
-    srcRoot: string;
-    config: import("../types.mjs").VovkStrictConfig;
-    clientImports: {
-        schema: string;
-        fetcher: string;
-        createRPC: string;
-        validateOnClient: string | null;
-        module: {
-            schema: string;
-            fetcher: string;
-            createRPC: string;
-            validateOnClient: string | null;
-        };
+    apiDirAbsolutePath: string | null;
+    srcRoot: string | null;
+    vovkCliPackage: {
+        version: string;
     };
+    config: import("vovk/internal").VovkStrictConfig;
+    packageJson: import("type-fest").PackageJson;
+    isNextInstalled: boolean;
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;

package/dist/getProjectInfo/index.mjs

@@ -1,45 +1,39 @@
 import path from 'node:path';
-import getConfig from './getConfig.mjs';
-import getLogger from '../utils/getLogger.mjs';
-export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {
+import { getConfig } from './getConfig/index.mjs';
+import { getPackageJson } from '../utils/getPackageJson.mjs';
+import { readFile } from 'node:fs/promises';
+export async function getProjectInfo({ port: givenPort, cwd = process.cwd(), configPath, srcRootRequired = true, logLevel, } = {
+    logLevel: 'info',
+}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
-    const { config, srcRoot, configAbsolutePaths, userConfig, error } = await getConfig({ clientOutDir, cwd });
-    const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
-    const apiDir = path.join(srcRoot, 'app', config.rootEntry);
-    const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/') + // windows fix
-        '/main.cjs';
-    const log = getLogger(config.logLevel);
+    const { config, srcRoot, configAbsolutePaths, log } = await getConfig({
+        configPath,
+        cwd,
+        logLevel,
+    });
+    const packageJson = await getPackageJson(cwd, log);
+    const isNextInstalled = !!packageJson?.dependencies?.next || !!packageJson?.devDependencies?.next;
+    if (srcRootRequired && !srcRoot) {
+        throw new Error(`Could not find app router directory at ${cwd}. Check Next.js docs for more info.`);
+    }
+    const apiRoot = `${config.outputConfig.origin ?? ''}/${config.rootEntry}`;
+    const apiDirAbsolutePath = srcRoot ? path.resolve(cwd, srcRoot, 'app', config.rootEntry) : null;
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
     }
-    if (!userConfig && configAbsolutePaths.length > 0) {
-        log.error(`Error reading config file at ${configAbsolutePaths[0]}: ${error?.message ?? 'Unknown Error'}`);
-    }
-    const getImportPath = (p) => (p.startsWith('.') ? path.relative(config.clientOutDir, p) : p);
-    const clientImports = {
-        schema: schemaOutImportPath,
-        fetcher: getImportPath(config.fetcherImport[0]),
-        createRPC: getImportPath(config.createRPCImport[0]),
-        validateOnClient: config.validateOnClientImport ? getImportPath(config.validateOnClientImport[0]) : null,
-        module: {
-            schema: schemaOutImportPath,
-            fetcher: getImportPath(config.fetcherImport[1] ?? config.fetcherImport[0]),
-            createRPC: getImportPath(config.createRPCImport[1] ?? config.createRPCImport[0]),
-            validateOnClient: config.validateOnClientImport
-                ? getImportPath(config.validateOnClientImport[1] ?? config.validateOnClientImport[0])
-                : null,
-        },
-    };
+    const vovkCliPackage = JSON.parse(await readFile(path.join(import.meta.dirname, '../../package.json'), 'utf-8'));
     return {
         cwd,
         port,
         apiRoot,
-        apiDir,
+        apiDirAbsolutePath,
         srcRoot,
+        vovkCliPackage,
         config,
-        clientImports,
+        packageJson,
+        isNextInstalled,
         log,
     };
 }

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --experimental-vm-modules --disable-warning=ExperimentalWarning
 import 'dotenv/config';
-import type { VovkConfig, VovkEnv } from './types.mjs';
-export type { VovkConfig, VovkEnv };
+import type { VovkEnv } from './types.mjs';
+export type { VovkEnv };