@pikku/cli 0.7.7 → 0.8.1

package/src/pikku-command-schemas.ts

@@ -0,0 +1,33 @@
+import { generateSchemas, saveSchemas } from './schema-generator.js'
+import { logCommandInfoAndTime } from './utils.js'
+import { PikkuCommand } from './types.js'
+
+export const pikkuSchemas: PikkuCommand = async (
+  logger,
+  { tsconfig, schemaDirectory, supportsImportAttributes },
+  { functions, http }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating schemas',
+    'Created schemas',
+    [false],
+    async () => {
+      const schemas = await generateSchemas(
+        logger,
+        tsconfig,
+        functions.typesMap,
+        functions.meta,
+        http.meta
+      )
+      await saveSchemas(
+        logger,
+        schemaDirectory,
+        schemas,
+        functions.typesMap,
+        functions.meta,
+        supportsImportAttributes
+      )
+    }
+  )
+}

package/src/runtimes/nextjs/pikku-command-nextjs.ts

@@ -0,0 +1,110 @@
+import {
+  logCommandInfoAndTime,
+  getPikkuFilesAndMethods,
+  getFileImportRelativePath,
+  writeFileInDir,
+} from '../../utils.js'
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js'
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuNext: PikkuCommand = async (
+  logger,
+  {
+    nextBackendFile,
+    nextHTTPFile,
+    httpRoutesMapDeclarationFile,
+    packageMappings,
+    fetchFile,
+    bootstrapFiles,
+  },
+  visitState,
+  options = {}
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating nextjs wrapper',
+    'Generated nextjs wrapper',
+    [
+      nextBackendFile === undefined && nextHTTPFile === undefined,
+      'nextjs outfile is not defined',
+    ],
+    async () => {
+      if (!nextBackendFile && !nextHTTPFile) {
+        throw new Error(
+          'nextBackendFile or nextHTTPFile is required in pikku config for nextJS'
+        )
+      }
+
+      if (nextHTTPFile && !fetchFile) {
+        throw new Error(
+          'fetchFile is required in pikku config in order for nextJS http wrapper to work'
+        )
+      }
+
+      if (nextBackendFile) {
+        const {
+          pikkuConfigFactory,
+          singletonServicesFactory,
+          sessionServicesFactory,
+        } = await getPikkuFilesAndMethods(
+          logger,
+          visitState,
+          packageMappings,
+          nextBackendFile,
+          options,
+          {
+            config: true,
+            singletonServicesFactory: true,
+            sessionServicesFactory: true,
+          }
+        )
+
+        const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`
+        const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`
+        const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`
+
+        const httpBootstrapPath = getFileImportRelativePath(
+          nextBackendFile,
+          bootstrapFiles.http,
+          packageMappings
+        )
+
+        const routesMapDeclarationPath = getFileImportRelativePath(
+          nextBackendFile,
+          httpRoutesMapDeclarationFile,
+          packageMappings
+        )
+
+        const content = serializeNextBackendWrapper(
+          httpBootstrapPath,
+          routesMapDeclarationPath,
+          pikkuConfigImport,
+          singletonServicesImport,
+          sessionServicesImport
+        )
+        await writeFileInDir(logger, nextBackendFile, content)
+      }
+
+      if (nextHTTPFile && fetchFile) {
+        const routesMapDeclarationPath = getFileImportRelativePath(
+          nextHTTPFile,
+          httpRoutesMapDeclarationFile,
+          packageMappings
+        )
+
+        const fetchPath = getFileImportRelativePath(
+          nextHTTPFile,
+          fetchFile,
+          packageMappings
+        )
+
+        const content = serializeNextHTTPWrapper(
+          routesMapDeclarationPath,
+          fetchPath
+        )
+        await writeFileInDir(logger, nextHTTPFile, content)
+      }
+    }
+  )
+}

package/src/schema-generator.ts

@@ -1,11 +1,12 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { logInfo, writeFileInDir } from './utils/utils.js'
+import { CLILogger, writeFileInDir } from './utils.js'
 import { mkdir, writeFile } from 'fs/promises'
 import { FunctionsMeta, JSONValue } from '@pikku/core'
 import { HTTPRoutesMeta } from '@pikku/core/http'
 import { TypesMap } from '@pikku/inspector'
 
 export async function generateSchemas(
+  logger: CLILogger,
   tsconfig: string,
   typesMap: TypesMap,
   functionMeta: FunctionsMeta,
@@ -52,10 +53,10 @@ export async function generateSchemas(
     } catch (e) {
       // Ignore rootless errors
       if (e instanceof RootlessError) {
-        console.error('Error generating schema since it has no root:', schema)
+        logger.error(`Error generating schema since it has no root: ${schema}`)
         return
       }
-      throw e
+      logger.error(`Error generating schema: ${schema}`)
     }
   })
 
@@ -63,6 +64,7 @@ export async function generateSchemas(
 }
 
 export async function saveSchemas(
+  logger: CLILogger,
   schemaParentDir: string,
   schemas: Record<string, JSONValue>,
   typesMap: TypesMap,
@@ -70,6 +72,7 @@ export async function saveSchemas(
   supportsImportAttributes: boolean
 ) {
   await writeFileInDir(
+    logger,
     `${schemaParentDir}/register.gen.ts`,
     'export const empty = null;'
   )
@@ -90,7 +93,7 @@ export async function saveSchemas(
   ])
 
   if (desiredSchemas.size === 0) {
-    logInfo(`• Skipping schemas since none found.\x1b[0m`)
+    logger.info(`• Skipping schemas since none found.\x1b[0m`)
     return
   }
 
@@ -117,8 +120,10 @@ addSchema('${schema}', ${schema})
     .join('\n')
 
   await writeFileInDir(
+    logger,
     `${schemaParentDir}/register.gen.ts`,
     `import { addSchema } from '@pikku/core/schema'
-${schemaImports}`
+${schemaImports}`,
+    { logWrite: true }
   )
 }

package/src/schemas.ts

@@ -0,0 +1,33 @@
+import { saveSchemas, generateSchemas } from './schema-generator.js'
+import { logCommandInfoAndTime } from './utils.js'
+import { PikkuCommand } from './types.js'
+
+export const pikkuSchemas: PikkuCommand = async (
+  logger,
+  { tsconfig, schemaDirectory, supportsImportAttributes },
+  { functions, http }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating schemas',
+    'Created schemas',
+    [false],
+    async () => {
+      const schemas = await generateSchemas(
+        logger,
+        tsconfig,
+        functions.typesMap,
+        functions.meta,
+        http.meta
+      )
+      await saveSchemas(
+        logger,
+        schemaDirectory,
+        schemas,
+        functions.typesMap,
+        functions.meta,
+        supportsImportAttributes
+      )
+    }
+  )
+}

package/src/{utils/serialize-import-map.ts → serialize-import-map.ts}

@@ -16,6 +16,11 @@ export const serializeImportMap = (
       return
     }
     const variables = paths.get(path) || []
+
+    if (uniqueName === '__object') {
+      return
+    }
+
     if (originalName === uniqueName) {
       variables.push(originalName)
     } else {