@pikku/cli 0.7.1 → 0.7.3

package/src/{utils.ts → utils/utils.ts}

@@ -1,5 +1,5 @@
 import { relative, dirname } from 'path'
-import { PathToNameAndType, InspectorState } from '@pikku/inspector'
+import { PathToNameAndType, InspectorState, TypesMap } from '@pikku/inspector'
 import { mkdir, writeFile } from 'fs/promises'
 import chalk from 'chalk'
 import { fileURLToPath } from 'url'
@@ -248,7 +248,7 @@ export const logPikkuLogo = () => {
   logPrimary(logo)
 
   const packageJson = JSON.parse(
-    readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8')
+    readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8')
   )
   logPrimary(`⚙️ Welcome to the Pikku CLI (v${packageJson.version})\n`)
 }
@@ -282,3 +282,21 @@ export const serializeFileImports = (
 
   return serializedOutput.join('\n')
 }
+
+export function generateCustomTypes(
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+  .map(([name, { type, references }]) => {
+    references.forEach((name) => {
+      const originalName = typesMap.getTypeMeta(name).originalName
+      requiredTypes.add(originalName)
+    })
+    return `export type ${name} = ${type}`
+  })
+  .join('\n')}`
+}

package/dist/src/serialize-typed-function-map.d.ts

@@ -1,4 +0,0 @@
-import { HTTPRoutesMeta } from '@pikku/core/http';
-import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
-export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/serialize-typed-function-map.js

@@ -1,107 +0,0 @@
-import { serializeImportMap } from './serialize-import-map.js';
-export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
-    const requiredTypes = new Set();
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for typescript to be aware of routes and their return types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-${serializedMetaTypes}
-
-interface RouteHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedRoutes}
-
-export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
-    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
-        ? RouteHandler<I, O>
-        : never;
-
-export type RoutesWithMethod<Method extends string> = {
-  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
-}[keyof RoutesMap];
-  `;
-};
-export function generateCustomTypes(typesMap, requiredTypes) {
-    return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-        .map(([name, { type, references }]) => {
-        references.forEach((name) => {
-            const originalName = typesMap.getTypeMeta(name).originalName;
-            requiredTypes.add(originalName);
-        });
-        return `export type ${name} = ${type}`;
-    })
-        .join('\n')}`;
-}
-function generateRoutes(routesMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect routes
-    const routesObj = {};
-    for (const meta of routesMeta) {
-        const { route, method, input, output } = meta;
-        // Initialize the route entry if it doesn't exist
-        if (!routesObj[route]) {
-            routesObj[route] = {};
-        }
-        // Store the input and output types separately for RouteHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add method entry
-        routesObj[route][method] = {
-            inputType,
-            outputType,
-        };
-    }
-    // Build the routes object as a string
-    let routesStr = 'export type RoutesMap = {\n';
-    for (const [routePath, methods] of Object.entries(routesObj)) {
-        routesStr += `  readonly '${routePath}': {\n`;
-        for (const [method, handler] of Object.entries(methods)) {
-            routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`;
-        }
-        routesStr += '  },\n';
-    }
-    routesStr += '};';
-    return routesStr;
-}
-const generateMetaTypes = (metaTypes, typesMap) => {
-    const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
-        const { uniqueName } = typesMap.getTypeMeta(_name);
-        const queryType = query && query.length > 0
-            ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
-            : undefined;
-        if (queryType) {
-            result.set(`${uniqueName}Query`, queryType);
-        }
-        const paramsType = params && params.length > 0
-            ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
-            : undefined;
-        if (paramsType) {
-            result.set(`${uniqueName}Params`, paramsType);
-        }
-        const bodyType = (body && body.length > 0) || (params && params.length > 0)
-            ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
-            : uniqueName;
-        if (bodyType) {
-            result.set(`${uniqueName}Body`, bodyType);
-        }
-        return result;
-    }, new Map());
-    return `
-// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
-${Array.from(nameToTypeMap.entries())
-        .map(([name, type]) => `export type ${name} = ${type} & {}`)
-        .join('\n')}`;
-};

package/src/serialize-typed-function-map.ts

@@ -1,151 +0,0 @@
-import { HTTPRoutesMeta } from '@pikku/core/http'
-import { serializeImportMap } from './serialize-import-map.js'
-import { MetaInputTypes, TypesMap } from '@pikku/inspector'
-
-export const serializeTypedRoutesMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  routesMeta: HTTPRoutesMeta,
-  metaTypes: MetaInputTypes
-) => {
-  const requiredTypes = new Set<string>()
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
-  const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
-  const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes)
-
-  const serializedImportMap = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    requiredTypes
-  )
-
-  return `/**
- * This provides the structure needed for typescript to be aware of routes and their return types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-${serializedMetaTypes}
-
-interface RouteHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedRoutes}
-
-export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
-    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
-        ? RouteHandler<I, O>
-        : never;
-
-export type RoutesWithMethod<Method extends string> = {
-  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
-}[keyof RoutesMap];
-  `
-}
-
-export function generateCustomTypes(
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-  .map(([name, { type, references }]) => {
-    references.forEach((name) => {
-      const originalName = typesMap.getTypeMeta(name).originalName
-      requiredTypes.add(originalName)
-    })
-    return `export type ${name} = ${type}`
-  })
-  .join('\n')}`
-}
-
-function generateRoutes(
-  routesMeta: HTTPRoutesMeta,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  // Initialize an object to collect routes
-  const routesObj: Record<
-    string,
-    Record<string, { inputType: string; outputType: string }>
-  > = {}
-
-  for (const meta of routesMeta) {
-    const { route, method, input, output } = meta
-
-    // Initialize the route entry if it doesn't exist
-    if (!routesObj[route]) {
-      routesObj[route] = {}
-    }
-
-    // Store the input and output types separately for RouteHandler
-    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
-    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
-
-    requiredTypes.add(inputType)
-    requiredTypes.add(outputType)
-
-    // Add method entry
-    routesObj[route][method] = {
-      inputType,
-      outputType,
-    }
-  }
-
-  // Build the routes object as a string
-  let routesStr = 'export type RoutesMap = {\n'
-
-  for (const [routePath, methods] of Object.entries(routesObj)) {
-    routesStr += `  readonly '${routePath}': {\n`
-    for (const [method, handler] of Object.entries(methods)) {
-      routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`
-    }
-    routesStr += '  },\n'
-  }
-
-  routesStr += '};'
-
-  return routesStr
-}
-
-const generateMetaTypes = (metaTypes: MetaInputTypes, typesMap: TypesMap) => {
-  const nameToTypeMap = Array.from(metaTypes.entries()).reduce<
-    Map<string, string>
-  >((result, [_name, { query, body, params }]) => {
-    const { uniqueName } = typesMap.getTypeMeta(_name)
-    const queryType =
-      query && query.length > 0
-        ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
-        : undefined
-    if (queryType) {
-      result.set(`${uniqueName}Query`, queryType)
-    }
-    const paramsType =
-      params && params.length > 0
-        ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
-        : undefined
-    if (paramsType) {
-      result.set(`${uniqueName}Params`, paramsType)
-    }
-    const bodyType =
-      (body && body.length > 0) || (params && params.length > 0)
-        ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
-        : uniqueName!
-    if (bodyType) {
-      result.set(`${uniqueName}Body`, bodyType)
-    }
-    return result
-  }, new Map())
-
-  return `
-// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
-${Array.from(nameToTypeMap.entries())
-  .map(([name, type]) => `export type ${name} = ${type} & {}`)
-  .join('\n')}`
-}