vovk-cli 0.0.1-draft.98 → 0.0.1

package/dist/utils/normalizeOpenAPIMixin.mjs

@@ -0,0 +1,96 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as YAML from 'yaml';
+import { chalkHighlightThing } from './chalkHighlightThing.mjs';
+import camelCase from 'lodash/camelCase.js';
+import { generateFnName } from './generateFnName.mjs';
+const normalizeGetModuleName = (getModuleName) => {
+    if (typeof getModuleName === 'string') {
+        const moduleName = getModuleName;
+        getModuleName = () => moduleName;
+    }
+    else if (typeof getModuleName !== 'function') {
+        throw new Error('getModuleName must be a function or one of the predefined strings');
+    }
+    return getModuleName;
+};
+const normalizeGetMethodName = (getMethodName) => {
+    if (getMethodName === 'camel-case-operation-id') {
+        getMethodName = ({ operationObject }) => {
+            const operationId = operationObject.operationId;
+            if (!operationId) {
+                throw new Error('Operation ID is required for camel-case method name generation');
+            }
+            return camelCase(operationId);
+        };
+    }
+    else if (getMethodName === 'auto') {
+        getMethodName = ({ operationObject, method, path }) => {
+            const operationId = operationObject.operationId;
+            const isCamelCase = operationId && /^[a-z][a-zA-Z0-9]*$/.test(operationId);
+            const isSnakeCase = operationId && /^[a-z][a-z0-9_]+$/.test(operationId);
+            return isCamelCase ? operationId : isSnakeCase ? camelCase(operationId) : generateFnName(method, path);
+        };
+    }
+    else if (typeof getMethodName !== 'function') {
+        throw new Error('getMethodName must be a function or one of the predefined strings');
+    }
+    return getMethodName;
+};
+async function getOpenApiSpecLocal(openApiSpecFilePath, cwd) {
+    const openApiSpecAbsolutePath = path.resolve(cwd, openApiSpecFilePath);
+    const fileName = path.basename(openApiSpecAbsolutePath);
+    if (!fileName.endsWith('.json') && !fileName.endsWith('.yaml') && !fileName.endsWith('.yml')) {
+        throw new Error(`Invalid OpenAPI spec file format: ${fileName}. Please provide a JSON or YAML file.`);
+    }
+    const openApiSpecContent = await fs.readFile(openApiSpecAbsolutePath, 'utf8');
+    return (fileName.endsWith('.json') ? JSON.parse(openApiSpecContent) : YAML.parse(openApiSpecContent));
+}
+async function getOpenApiSpecRemote({ cwd, url, fallback, log, }) {
+    const resp = await fetch(url);
+    const text = await resp.text();
+    if (!resp.ok) {
+        if (fallback) {
+            log.warn(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}. Falling back to ${chalkHighlightThing(fallback)}`);
+            return getOpenApiSpecLocal(fallback, cwd);
+        }
+        throw new Error(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}`);
+    }
+    if (fallback) {
+        const fallbackAbsolutePath = path.resolve(cwd, fallback);
+        const existingFallback = await fs.readFile(fallbackAbsolutePath, 'utf8').catch(() => null);
+        if (existingFallback !== text) {
+            await fs.mkdir(path.dirname(fallbackAbsolutePath), { recursive: true });
+            await fs.writeFile(fallbackAbsolutePath, text);
+            log.info(`Saved OpenAPI spec to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+        else {
+            log.debug(`OpenAPI spec at ${chalkHighlightThing(url)} is unchanged. Skipping write to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+    }
+    return (text.trim().startsWith('{') || text.trim().startsWith('[') ? JSON.parse(text) : YAML.parse(text));
+}
+export async function normalizeOpenAPIMixin({ 
+// mixinName,
+mixinModule, log, cwd = process.cwd(), }) {
+    const { source, getModuleName, getMethodName } = mixinModule;
+    let openAPIObject;
+    if ('url' in source) {
+        openAPIObject = await getOpenApiSpecRemote({ url: source.url, fallback: source.fallback, log, cwd });
+    }
+    else if ('file' in source) {
+        openAPIObject = await getOpenApiSpecLocal(source.file, cwd);
+    }
+    else if ('object' in source) {
+        openAPIObject = source.object;
+    }
+    else {
+        throw new Error('Invalid source type for OpenAPI configuration');
+    }
+    return {
+        ...mixinModule,
+        source: { object: openAPIObject },
+        getModuleName: normalizeGetModuleName(getModuleName),
+        getMethodName: normalizeGetMethodName(getMethodName),
+    };
+}

package/dist/utils/pickSegmentFullSchema.d.mts

@@ -0,0 +1,3 @@
+import { type VovkSchema } from 'vovk';
+export declare function pickSegmentFullSchema(schema: VovkSchema, segmentNames: string[]): VovkSchema;
+export declare function omitSegmentFullSchema(schema: VovkSchema, segmentNames: string[]): VovkSchema;

package/dist/utils/pickSegmentFullSchema.mjs

@@ -0,0 +1,15 @@
+import { VovkSchemaIdEnum } from 'vovk/internal';
+export function pickSegmentFullSchema(schema, segmentNames) {
+    return {
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        meta: schema.meta,
+        segments: Object.fromEntries(segmentNames.map((segmentName) => [segmentName, schema.segments[segmentName]])),
+    };
+}
+export function omitSegmentFullSchema(schema, segmentNames) {
+    return {
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        meta: schema.meta,
+        segments: Object.fromEntries(Object.entries(schema.segments).filter(([segmentName]) => !segmentNames.includes(segmentName))),
+    };
+}

package/dist/utils/prettify.d.mts

@@ -1 +1 @@
-export default function prettify(code: string, absoluteFilePath: string): Promise<string>;
+export declare function prettify(code: string, absoluteFilePath: string): Promise<string>;

package/dist/utils/prettify.mjs

@@ -1,5 +1,5 @@
 import prettier from 'prettier';
-export default async function prettify(code, absoluteFilePath) {
+export async function prettify(code, absoluteFilePath) {
     const options = await prettier.resolveConfig(absoluteFilePath);
     const finalOptions = {
         ...options,

package/dist/utils/removeUnlistedDirectories.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Removes all directories in a folder that aren't in the provided allowlist
+ * Supports nested directory paths like 'foo/bar/baz'
+ *
+ * @param folderPath - The path to the folder to process
+ * @param allowedDirs - Array of relative directory paths to keep
+ * @returns Promise that resolves when all operations are complete
+ */
+export declare function removeUnlistedDirectories(folderPath: string, allowedDirs: string[]): Promise<void>;

package/dist/utils/removeUnlistedDirectories.mjs

@@ -0,0 +1,60 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getFileSystemEntryType, FileSystemEntryType } from './getFileSystemEntryType.mjs';
+/**
+ * Removes all directories in a folder that aren't in the provided allowlist
+ * Supports nested directory paths like 'foo/bar/baz'
+ *
+ * @param folderPath - The path to the folder to process
+ * @param allowedDirs - Array of relative directory paths to keep
+ * @returns Promise that resolves when all operations are complete
+ */
+export async function removeUnlistedDirectories(folderPath, allowedDirs) {
+    // Normalize all allowed paths to use the system-specific separator
+    const normalizedAllowedDirs = allowedDirs.map((dir) => dir.split('/').join(path.sep));
+    // Process the directory tree recursively
+    await processDirectory(folderPath, '', normalizedAllowedDirs);
+}
+/**
+ * Recursively processes directories to determine which should be kept or removed
+ *
+ * @param basePath - The absolute base path being processed
+ * @param relativePath - The current relative path from the base
+ * @param allowedDirs - Normalized list of allowed directory paths
+ */
+async function processDirectory(basePath, relativePath, allowedDirs) {
+    const currentDirPath = path.join(basePath, relativePath);
+    // check if the current path is a directory
+    const type = await getFileSystemEntryType(currentDirPath);
+    if (type !== FileSystemEntryType.DIRECTORY) {
+        // If it's not a directory, return early
+        return;
+    }
+    // Read all entries in the current directory
+    const entries = await fs.readdir(currentDirPath, { withFileTypes: true });
+    // Process only directories
+    const dirEntries = entries.filter((entry) => entry.isDirectory());
+    // Check each directory
+    for (const dir of dirEntries) {
+        // Calculate the new relative path
+        const newRelativePath = relativePath ? path.join(relativePath, dir.name) : dir.name;
+        // Check if this directory or any of its subdirectories should be kept
+        const shouldKeep = allowedDirs.some((allowedDir) => {
+            // Direct match
+            if (allowedDir === newRelativePath)
+                return true;
+            // Check if it's a parent path of an allowed directory
+            // e.g. "foo" is a parent of "foo/bar/baz"
+            return allowedDir.startsWith(newRelativePath + path.sep);
+        });
+        if (shouldKeep) {
+            // Recursively process this directory's contents
+            await processDirectory(basePath, newRelativePath, allowedDirs);
+        }
+        else {
+            // Remove this directory since it's not in the allowed list
+            const fullPath = path.join(basePath, newRelativePath);
+            await fs.rm(fullPath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/utils/resolveAbsoluteModulePath.d.mts

@@ -0,0 +1,2 @@
+export declare function getPathUpToModule(moduleName: string, fullPath: string): string;
+export declare function resolveAbsoluteModulePath(modulePath: string, cwd: string): string;

package/dist/utils/resolveAbsoluteModulePath.mjs

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { getPublicModuleNameFromPath } from './getPublicModuleNameFromPath.mjs';
+// Returns the path up to and including the last occurrence of the given module name
+export function getPathUpToModule(moduleName, fullPath) {
+    const idx = fullPath.lastIndexOf(moduleName);
+    if (idx === -1)
+        return moduleName;
+    return fullPath.slice(0, idx + moduleName.length);
+}
+export function resolveAbsoluteModulePath(modulePath, cwd) {
+    // If it's an absolute path or starts with '.' (relative), resolve it directly
+    if (modulePath.startsWith('/') || modulePath.startsWith('.')) {
+        return path.resolve(cwd, modulePath);
+    }
+    // For npm package names, use Node's module resolution algorithm
+    try {
+        const { moduleName, restPath } = getPublicModuleNameFromPath(modulePath);
+        if (!moduleName) {
+            throw new Error(`Invalid module path: ${modulePath}`);
+        }
+        const require = createRequire(import.meta.url);
+        const resolved = require.resolve(moduleName);
+        return path.resolve(getPathUpToModule(moduleName, path.dirname(resolved)), restPath);
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.error(`Error resolving module path: ${modulePath}`, e);
+        // If resolution fails, fall back to the original behavior
+        return path.resolve(cwd, './node_modules', modulePath);
+    }
+}

package/dist/utils/updateConfigProperty.d.mts

@@ -0,0 +1,2 @@
+export declare function updateConfigProperty(sourceCode: string, pathToProperty: string[], newValue: unknown): string;
+export declare function updateConfigFileProperty(absolutePathToTheFile: string, pathToProperty: string[], newValue: unknown): string;

package/dist/utils/updateConfigProperty.mjs

@@ -0,0 +1,132 @@
+import { Project, QuoteKind, IndentationText, NewLineKind, SyntaxKind, Node, } from 'ts-morph';
+export function updateConfigProperty(sourceCode, pathToProperty, newValue) {
+    const project = createProject();
+    const sourceFile = project.createSourceFile('config-temp.mts', sourceCode, { overwrite: true });
+    return mutateConfig(sourceFile, pathToProperty, newValue);
+}
+export function updateConfigFileProperty(absolutePathToTheFile, pathToProperty, newValue) {
+    const project = createProject();
+    const sourceFile = project.addSourceFileAtPath(absolutePathToTheFile);
+    const updated = mutateConfig(sourceFile, pathToProperty, newValue);
+    sourceFile.saveSync();
+    return updated;
+}
+function createProject() {
+    return new Project({
+        manipulationSettings: {
+            quoteKind: QuoteKind.Single,
+            indentationText: IndentationText.TwoSpaces,
+            newLineKind: NewLineKind.LineFeed,
+        },
+    });
+}
+function findPropertyAssignment(objectNode, key) {
+    const properties = objectNode.getProperties();
+    for (const prop of properties) {
+        if (Node.isPropertyAssignment(prop)) {
+            const name = prop.getName();
+            // Handle both quoted and unquoted property names
+            const unquotedName = name.replace(/^['"]|['"]$/g, '');
+            if (unquotedName === key || name === key) {
+                return prop;
+            }
+        }
+    }
+    return undefined;
+}
+function mutateConfig(sourceFile, pathToProperty, newValue) {
+    const variableDeclaration = sourceFile.getVariableDeclaration('config');
+    if (!variableDeclaration) {
+        throw new Error('config variable not found in the file.');
+    }
+    const initializer = variableDeclaration.getInitializer();
+    if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+        throw new Error('config is not initialized as an object literal.');
+    }
+    let currentNode = initializer;
+    for (let i = 0; i < pathToProperty.length; i++) {
+        const key = pathToProperty[i];
+        const isLastKey = i === pathToProperty.length - 1;
+        const property = findPropertyAssignment(currentNode, key);
+        if (!property) {
+            // Property does not exist
+            if (newValue === undefined) {
+                // Nothing to remove
+                return sourceFile.getFullText();
+            }
+            if (isLastKey) {
+                // Last key - add the final value
+                currentNode.addPropertyAssignment({
+                    name: key,
+                    initializer: (writer) => writeInitializer(writer, newValue),
+                });
+            }
+            else {
+                // Need to create nested object
+                const newObjectAssignment = currentNode.addPropertyAssignment({
+                    name: key,
+                    initializer: '{}',
+                });
+                currentNode = newObjectAssignment.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+            }
+        }
+        else {
+            // Property exists
+            const propInitializer = property.getInitializer();
+            if (isLastKey) {
+                // Last key - update or remove the value
+                if (newValue === undefined) {
+                    property.remove();
+                }
+                else {
+                    property.setInitializer((writer) => writeInitializer(writer, newValue));
+                }
+            }
+            else {
+                // Need to go deeper into existing object
+                if (propInitializer && Node.isObjectLiteralExpression(propInitializer)) {
+                    currentNode = propInitializer;
+                }
+                else {
+                    throw new Error(`Cannot traverse into non-object property at ${pathToProperty.slice(0, i + 1).join('.')}.`);
+                }
+            }
+        }
+    }
+    return sourceFile.getFullText();
+}
+function writeInitializer(writer, value) {
+    if (typeof value === 'string') {
+        writer.quote(value);
+    }
+    else if (typeof value === 'number' || typeof value === 'boolean') {
+        writer.write(value.toString());
+    }
+    else if (typeof value === 'function') {
+        writer.write(value.toString());
+    }
+    else if (Array.isArray(value)) {
+        writer.write('[');
+        value.forEach((item, index) => {
+            if (index > 0)
+                writer.write(', ');
+            writeInitializer(writer, item);
+        });
+        writer.write(']');
+    }
+    else if (typeof value === 'object' && value !== null) {
+        writer.write('{');
+        const entries = Object.entries(value);
+        entries.forEach(([k, v], index) => {
+            if (index > 0)
+                writer.write(', ');
+            writer.write(k);
+            writer.write(': ');
+            writeInitializer(writer, v);
+        });
+        writer.write('}');
+    }
+    else {
+        writer.write('null');
+    }
+}

package/module-templates/arktype/controller.ts.ejs

@@ -0,0 +1,90 @@
+<% const vars = { 
+  ModuleName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+outDir: <%= t.defaultOutDir %>
+fileName: <%= vars.ModuleName + '.ts' %>
+sourceName: <%= vars.ModuleName %>
+compiledName: <%= t.TheThing + 'RPC' %>
+---
+
+import { procedure, prefix, get, put, post, del, operation } from 'vovk';
+import { type } from 'arktype';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %><%= t.nodeNextResolutionExt.ts %>';
+<% } %>
+
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ModuleName %> {
+    @operation({
+      summary: 'Get <%= t.theThings %>',
+    })
+    @get()
+    static get<%= t.TheThings %> = procedure().handle(() => {
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.get<%= t.TheThings %>();
+        <% } else { %>
+        return { message: 'TODO: get <%= t.theThings %>' };
+        <% } %>
+    });
+
+    @operation({
+      summary: 'Get single <%= t.theThing %>',
+    })
+    @get('{id}')
+    static getSingle<%= t.TheThing %> = procedure({
+        params: type({ id: type('string') }),
+    }).handle((_req, { id }) => {
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.getSingle<%= t.TheThing %>(id);
+        <% } else { %>
+        return { message: 'TODO: get single <%= t.theThing %>', id };
+        <% } %>
+    });
+
+    @operation({
+        summary: 'Update <%= t.theThing %>',
+    })
+    @put('{id}')
+    static update<%= t.TheThing %> = procedure({
+        body: type({ todo: type('true') }),
+        params: type({ id: type('string') }),
+    }).handle(async (req, { id }) => {
+        const body = await req.json();
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, body);
+        <% } else { %>
+        return { message: `TODO: update <%= t.theThing %>`, id, body };
+        <% } %>
+    });
+
+    @operation({
+      summary: 'Create <%= t.theThing %>',
+    })
+    @post()
+    static create<%= t.TheThing %> = procedure({
+        body: type({ todo: type('true') }),
+    }).handle(async (req) => {
+        const body = await req.json();
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.create<%= t.TheThing %>(body);
+        <% } else { %>
+        return { message: `TODO: create <%= t.theThing %>`, body };
+        <% } %>
+    });
+
+    @operation({
+      summary: 'Delete <%= t.theThing %>',
+    })
+    @del('{id}')
+    static delete<%= t.TheThing %> = procedure({
+        params: type({ id: type('string') }),
+    }).handle((_req, { id }) => {
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.delete<%= t.TheThing %>(id);
+        <% } else { %>
+        return { message: `TODO: delete <%= t.theThing %>`, id };
+        <% } %>
+    });
+}

package/module-templates/type/controller.ts.ejs

@@ -0,0 +1,80 @@
+<% const vars = { 
+  ControllerName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+outDir: <%= t.defaultOutDir %>
+fileName: <%= vars.ControllerName + '.ts' %>
+sourceName: <%= vars.ControllerName %>
+compiledName: <%= t.TheThing + 'RPC' %>
+---
+
+import { prefix, get, put, post, del, operation, type VovkRequest } from 'vovk';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %><%= t.nodeNextResolutionExt.ts %>';
+<% } %>
+
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ControllerName %> {
+    @operation({
+        summary: 'Get <%= t.theThings %>',
+    })
+    @get()
+    static get<%= t.TheThings %> = () => {
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.get<%= t.TheThings %>();
+        <% } else { %>
+        return { message: 'TODO: get <%= t.theThings %>' };
+        <% } %>
+    };
+
+    @operation({
+        summary: 'Get single <%= t.theThing %>',
+    })
+    @get('{id}')
+    static getSingle<%= t.TheThing %> = (_req: VovkRequest, { id }: { id: string }) => {
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.getSingle<%= t.TheThing %>(id);
+        <% } else { %>
+        return { message: 'TODO: get single <%= t.theThing %>', id };
+        <% } %>
+    };
+
+    @operation({
+        summary: 'Update <%= t.theThing %>',
+    })
+    @put('{id}')
+    static update<%= t.TheThing %> = async (req: VovkRequest<{ todo: true }>, { id }: { id: string }) => {
+        const body = await req.json();
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, body);
+        <% } else { %>
+        return { message: `TODO: update <%= t.theThing %>`, id, body };
+        <% } %>
+    };
+
+    @operation({
+        summary: 'Create <%= t.theThing %>',
+    })
+    @post()
+    static create<%= t.TheThing %> = async (req: VovkRequest<{ todo: true }>) => {
+        const body = await req.json();
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.create<%= t.TheThing %>(body);
+        <% } else { %>
+        return { message: `TODO: create <%= t.theThing %>`, body };
+        <% } %>
+    };
+
+    @operation({
+        summary: 'Delete <%= t.theThing %>',
+    })
+    @del('{id}')
+    static delete<%= t.TheThing %> = (_req: VovkRequest, { id }: { id: string }) => {
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.delete<%= t.TheThing %>(id);
+        <% } else { %>
+        return { message: `TODO: delete <%= t.theThing %>`, id };
+        <% } %>
+    };
+}

package/module-templates/type/service.ts.ejs

@@ -0,0 +1,43 @@
+<% const vars = {
+  ControllerName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+outDir: <%= t.defaultOutDir %>
+fileName: <%= vars.ServiceName + '.ts' %>
+sourceName: <%= vars.ServiceName %>
+---
+
+import type { VovkBody, VovkParams } from 'vovk';
+import type <%= vars.ControllerName %> from './<%= vars.ControllerName %><%= t.nodeNextResolutionExt.ts %>';
+
+export default class <%= vars.ServiceName %> {
+  static get<%= t.TheThings %> = () => {
+    return { message: 'TODO: get <%= t.theThings %>' };
+  };
+
+  static getSingle<%= t.TheThing %> = (
+    id: VovkParams<typeof <%= vars.ControllerName %>.getSingle<%= t.TheThing %>>['id']
+  ) => {
+    return { message: 'TODO: get single <%= t.theThing %>', id };
+  }
+
+  static update<%= t.TheThing %> = (
+    id: VovkParams<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>['id'],
+    body: VovkBody<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>
+  ) => {
+    return { message: `TODO: update <%= t.theThing %>`, id, body };
+  };
+
+  static create<%= t.TheThing %> = (
+    body: VovkBody<typeof <%= vars.ControllerName %>.create<%= t.TheThing %>>
+  ) => {
+    return { message: `TODO: create <%= t.theThing %>`, body };
+  };
+
+  static delete<%= t.TheThing %> = (
+    id: VovkParams<typeof <%= vars.ControllerName %>.delete<%= t.TheThing %>>['id']
+  ) => {
+    return { message: `TODO: delete <%= t.theThing %>`, id };
+  };
+}