@pikku/cli 0.6.6

package/bin/pikku-scheduler.ts

@@ -0,0 +1,61 @@
+import { Command } from 'commander'
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  logPikkuLogo,
+  PikkuCLIOptions,
+  writeFileInDir,
+} from '../src/utils.js'
+import {
+  serializeSchedulerMeta,
+  serializeSchedulers,
+} from '../src/scheduler/serialize-schedulers.js'
+import { inspectorGlob } from '../src/inspector-glob.js'
+
+export const pikkuScheduler = async (
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Finding scheduled tasks',
+    'Found scheduled tasks',
+    [visitState.scheduledTasks.files.size === 0],
+    async () => {
+      const { schedulersFile, packageMappings } = cliConfig
+      const { scheduledTasks } = visitState
+      const content = [
+        serializeSchedulers(
+          schedulersFile,
+          scheduledTasks.files,
+          packageMappings
+        ),
+        serializeSchedulerMeta(scheduledTasks.meta),
+      ]
+      await writeFileInDir(schedulersFile, content.join('\n\n'))
+    }
+  )
+}
+
+async function action(cliOptions: PikkuCLIOptions): Promise<void> {
+  logPikkuLogo()
+
+  const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
+    'rootDir',
+    'routeDirectories',
+    'routesFile',
+  ])
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.routeDirectories
+  )
+  await pikkuScheduler(cliConfig, visitState)
+}
+
+export const schedules = (program: Command): void => {
+  program
+    .command('scheduler')
+    .description('Find all scheduled tasks to import')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku-schemas.ts

@@ -0,0 +1,51 @@
+import { Command } from 'commander'
+import { saveSchemas, generateSchemas } from '../src/schema/schema-generator.js'
+
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils.js'
+import { inspectorGlob } from '../src/inspector-glob.js'
+
+export const pikkuSchemas = async (
+  { tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig,
+  { http }: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Creating schemas',
+    'Created schemas',
+    [false],
+    async () => {
+      const schemas = await generateSchemas(tsconfig, http.typesMap, http.meta)
+      await saveSchemas(
+        schemaDirectory,
+        schemas,
+        http.typesMap,
+        http.meta,
+        supportsImportAttributes
+      )
+    }
+  )
+}
+
+async function action({ config }: { config?: string }): Promise<void> {
+  logPikkuLogo()
+
+  const cliConfig = await getPikkuCLIConfig(config, [
+    'routeDirectories',
+    'schemaDirectory',
+    'tsconfig',
+  ])
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.routeDirectories
+  )
+  await pikkuSchemas(cliConfig, visitState)
+}
+
+export const schemas = (program: Command): void => {
+  program
+    .command('schemas')
+    .description('Generate schemas for all the expected function input types')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku-websocket.ts

@@ -0,0 +1,54 @@
+import { Command } from 'commander'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  logPikkuLogo,
+  PikkuCLIOptions,
+  writeFileInDir,
+} from '../src/utils.js'
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { serializeWebsocketWrapper } from '../src/channels/serialize-websocket-wrapper.js'
+
+export const pikkuWebSocket = async ({
+  websocketFile,
+  channelsMapDeclarationFile,
+  packageMappings,
+}: PikkuCLIConfig) => {
+  await logCommandInfoAndTime(
+    'Generating websocket wrapper',
+    'Generated websocket wrapper',
+    [websocketFile === undefined, 'websocketFile is required in pikku config'],
+    async () => {
+      if (!websocketFile) {
+        throw new Error('fetchFile is required in pikku config')
+      }
+
+      const channelsMapDeclarationPath = getFileImportRelativePath(
+        websocketFile,
+        channelsMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)]
+      await writeFileInDir(websocketFile, content.join('\n'))
+    }
+  )
+}
+
+export const action = async (options: PikkuCLIOptions): Promise<void> => {
+  logPikkuLogo()
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
+    true
+  )
+  await pikkuWebSocket(cliConfig)
+}
+
+export const websocket = (program: Command): void => {
+  program
+    .command('websocket')
+    .description('generate websocket wrapper')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from 'commander'
+import { schemas } from './pikku-schemas.js'
+import { routes } from './pikku-routes.js'
+import { nextjs } from './pikku-nextjs.js'
+import { all } from './pikku-all.js'
+import { functionTypes } from './pikku-function-types.js'
+import { routesMap } from './pikku-routes-map.js'
+import { fetch } from './pikku-fetch.js'
+import { channels } from './pikku-channels.js'
+import { schedules } from './pikku-scheduler.js'
+
+const program = new Command('pikku')
+program.usage('[command]')
+
+all(program)
+routes(program)
+routesMap(program)
+functionTypes(program)
+schemas(program)
+nextjs(program)
+fetch(program)
+channels(program)
+schedules(program)
+
+program.parse(process.argv)

package/cli.schema.json

@@ -0,0 +1,212 @@
+{
+  "$ref": "#/definitions/PikkuCLIConfig",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "OpenAPISpecInfo": {
+      "additionalProperties": false,
+      "properties": {
+        "externalDocs": {
+          "additionalProperties": false,
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": ["url"],
+          "type": "object"
+        },
+        "info": {
+          "additionalProperties": false,
+          "properties": {
+            "contact": {
+              "additionalProperties": false,
+              "properties": {
+                "email": {
+                  "type": "string"
+                },
+                "name": {
+                  "type": "string"
+                },
+                "url": {
+                  "type": "string"
+                }
+              },
+              "type": "object"
+            },
+            "description": {
+              "type": "string"
+            },
+            "license": {
+              "additionalProperties": false,
+              "properties": {
+                "name": {
+                  "type": "string"
+                },
+                "url": {
+                  "type": "string"
+                }
+              },
+              "required": ["name"],
+              "type": "object"
+            },
+            "termsOfService": {
+              "type": "string"
+            },
+            "title": {
+              "type": "string"
+            },
+            "version": {
+              "type": "string"
+            }
+          },
+          "required": ["title", "version", "description"],
+          "type": "object"
+        },
+        "security": {
+          "items": {
+            "additionalProperties": {
+              "items": {},
+              "type": "array"
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "securitySchemes": {
+          "type": "object"
+        },
+        "servers": {
+          "items": {
+            "additionalProperties": false,
+            "properties": {
+              "description": {
+                "type": "string"
+              },
+              "url": {
+                "type": "string"
+              }
+            },
+            "required": ["url"],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "tags": {
+          "items": {
+            "additionalProperties": false,
+            "properties": {
+              "description": {
+                "type": "string"
+              },
+              "name": {
+                "type": "string"
+              }
+            },
+            "required": ["name"],
+            "type": "object"
+          },
+          "type": "array"
+        }
+      },
+      "required": ["info", "servers"],
+      "type": "object"
+    },
+    "PikkuCLIConfig": {
+      "additionalProperties": false,
+      "properties": {
+        "$schema": {
+          "type": "string"
+        },
+        "bootstrapFile": {
+          "type": "string"
+        },
+        "channelsFile": {
+          "type": "string"
+        },
+        "channelsMapDeclarationFile": {
+          "type": "string"
+        },
+        "configDir": {
+          "type": "string"
+        },
+        "extends": {
+          "type": "string"
+        },
+        "fetchFile": {
+          "type": "string"
+        },
+        "nextJSfile": {
+          "type": "string"
+        },
+        "openAPI": {
+          "additionalProperties": false,
+          "properties": {
+            "additionalInfo": {
+              "$ref": "#/definitions/OpenAPISpecInfo"
+            },
+            "outputFile": {
+              "type": "string"
+            }
+          },
+          "required": ["outputFile", "additionalInfo"],
+          "type": "object"
+        },
+        "outDir": {
+          "type": "string"
+        },
+        "packageMappings": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "type": "object"
+        },
+        "rootDir": {
+          "type": "string"
+        },
+        "routeDirectories": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "routesFile": {
+          "type": "string"
+        },
+        "routesMapDeclarationFile": {
+          "type": "string"
+        },
+        "schedulersFile": {
+          "type": "string"
+        },
+        "schemaDirectory": {
+          "type": "string"
+        },
+        "tsconfig": {
+          "type": "string"
+        },
+        "typesDeclarationFile": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "bootstrapFile",
+        "channelsFile",
+        "channelsMapDeclarationFile",
+        "configDir",
+        "packageMappings",
+        "rootDir",
+        "routeDirectories",
+        "routesFile",
+        "routesMapDeclarationFile",
+        "schedulersFile",
+        "schemaDirectory",
+        "tsconfig",
+        "typesDeclarationFile"
+      ],
+      "type": "object"
+    }
+  }
+}

package/dist/bin/pikku-all.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import { PikkuCLIOptions } from '../src/utils.js';
+export declare const action: (options: PikkuCLIOptions) => Promise<void>;
+export declare const all: (program: Command) => void;

package/dist/bin/pikku-all.js

@@ -0,0 +1,71 @@
+import { getFileImportRelativePath, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { pikkuRoutes } from './pikku-routes.js';
+import { pikkuFunctionTypes } from './pikku-function-types.js';
+import { pikkuHTTPMap } from './pikku-routes-map.js';
+import { existsSync } from 'fs';
+import { pikkuFetch } from './pikku-fetch.js';
+import { pikkuChannelsMap } from './pikku-channels-map.js';
+import { pikkuChannels } from './pikku-channels.js';
+import { pikkuNext } from './pikku-nextjs.js';
+import { pikkuOpenAPI } from './pikku-openapi.js';
+import { pikkuScheduler } from './pikku-scheduler.js';
+import { pikkuSchemas } from './pikku-schemas.js';
+import { pikkuWebSocket } from './pikku-websocket.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const action = async (options) => {
+    logPikkuLogo();
+    const imports = [];
+    const addImport = (from) => {
+        imports.push(`import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`);
+    };
+    const cliConfig = await getPikkuCLIConfig(options.config, [], true);
+    let typesDeclarationFileExists = true;
+    let visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    if (!existsSync(cliConfig.typesDeclarationFile)) {
+        typesDeclarationFileExists = false;
+    }
+    await pikkuFunctionTypes(cliConfig, options, visitState);
+    // This is needed since the addRoutes function will add the routes to the visitState
+    if (!typesDeclarationFileExists) {
+        console.log(`\x1b[34m• Type file first created, inspecting again...\x1b[0m`);
+        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    }
+    const routes = await pikkuRoutes(cliConfig, visitState);
+    if (routes) {
+        await pikkuHTTPMap(cliConfig, visitState);
+        await pikkuFetch(cliConfig);
+        addImport(cliConfig.routesFile);
+    }
+    const scheduled = await pikkuScheduler(cliConfig, visitState);
+    if (scheduled) {
+        addImport(cliConfig.schedulersFile);
+    }
+    const channels = await pikkuChannels(cliConfig, visitState);
+    if (channels) {
+        await pikkuChannelsMap(cliConfig, visitState);
+        await pikkuWebSocket(cliConfig);
+        addImport(cliConfig.channelsFile);
+    }
+    const schemas = await pikkuSchemas(cliConfig, visitState);
+    if (schemas) {
+        addImport(`${cliConfig.schemaDirectory}/register.gen.ts`);
+    }
+    await pikkuNext(cliConfig, visitState, options);
+    if (cliConfig.openAPI) {
+        console.log(`\x1b[34m• OpenAPI requires a reinspection to pickup new generated types..\x1b[0m`);
+        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+        await pikkuOpenAPI(cliConfig, visitState);
+    }
+    await writeFileInDir(cliConfig.bootstrapFile, imports.join('\n'));
+};
+export const all = (program) => {
+    program
+        .command('all', { isDefault: true })
+        .description('Generate all the files used by pikku')
+        .option('-ct | --pikku-config-type', 'The type of your pikku config object')
+        .option('-ss | --singleton-services-factory-type', 'The type of your singleton services factory')
+        .option('-se | --session-services-factory-type', 'The type of your session services factory')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-channels-map.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuChannelsMap: ({ channelsMapDeclarationFile, packageMappings }: PikkuCLIConfig, state: InspectorState) => Promise<boolean>;
+export declare const channelsMap: (program: Command) => void;

package/dist/bin/pikku-channels-map.js

@@ -0,0 +1,27 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { serializeTypedChannelsMap } from '../src/channels/serialize-typed-channel-map.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuChannelsMap = async ({ channelsMapDeclarationFile, packageMappings }, state) => {
+    return await logCommandInfoAndTime('Creating channels map', 'Created channels map', [state.channels.files.size === 0], async () => {
+        const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.channels.typesMap, state.channels.meta);
+        await writeFileInDir(channelsMapDeclarationFile, content);
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
+        'rootDir',
+        'routeDirectories',
+        'routesFile',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuChannelsMap(cliConfig, visitState);
+}
+export const channelsMap = (program) => {
+    program
+        .command('channels-map')
+        .description('Generate a map of all channels to aid in type checking')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-channels.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuChannels: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+export declare const channels: (program: Command) => void;

package/dist/bin/pikku-channels.js

@@ -0,0 +1,32 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { serializeChannels, serializeChannelMeta, } from '../src/channels/serialize-channels.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuChannels = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
+        const { channelsFile, packageMappings } = cliConfig;
+        const { channels } = visitState;
+        const content = [
+            serializeChannels(channelsFile, channels.files, packageMappings),
+            serializeChannelMeta(channels.meta),
+        ];
+        await writeFileInDir(channelsFile, content.join('\n\n'));
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
+        'rootDir',
+        'routeDirectories',
+        'routesFile',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuChannels(cliConfig, visitState);
+}
+export const channels = (program) => {
+    program
+        .command('channels')
+        .description('Find all channels to import')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-fetch.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+import { PikkuCLIOptions } from '../src/utils.js';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+export declare const pikkuFetch: ({ fetchFile, routesMapDeclarationFile, packageMappings, }: PikkuCLIConfig) => Promise<void>;
+export declare const action: (options: PikkuCLIOptions) => Promise<void>;
+export declare const fetch: (program: Command) => void;

package/dist/bin/pikku-fetch.js

@@ -0,0 +1,25 @@
+import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { serializeFetchWrapper } from '../src/http/serialize-fetch-wrapper.js';
+export const pikkuFetch = async ({ fetchFile, routesMapDeclarationFile, packageMappings, }) => {
+    await logCommandInfoAndTime('Generating fetch wrapper', 'Generated fetch wrapper', [fetchFile === undefined, 'fetchFile is required in pikku config'], async () => {
+        if (!fetchFile) {
+            throw new Error('fetchFile is required in pikku config');
+        }
+        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, routesMapDeclarationFile, packageMappings);
+        const content = [serializeFetchWrapper(routesMapDeclarationPath)];
+        await writeFileInDir(fetchFile, content.join('\n'));
+    });
+};
+export const action = async (options) => {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], true);
+    await pikkuFetch(cliConfig);
+};
+export const fetch = (program) => {
+    program
+        .command('fetch')
+        .description('generate fetch wrapper')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-function-types.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+import { PikkuCLIOptions } from '../src/utils.js';
+export declare const pikkuFunctionTypes: ({ typesDeclarationFile: typesFile, packageMappings }: PikkuCLIConfig, options: PikkuCLIOptions, visitState: InspectorState) => Promise<void>;
+export declare const functionTypes: (program: Command) => void;

package/dist/bin/pikku-function-types.js

@@ -0,0 +1,32 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { pikkuRoutes } from './pikku-routes.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+import { serializePikkuTypes } from '../src/core/serialize-pikku-types.js';
+export const pikkuFunctionTypes = async ({ typesDeclarationFile: typesFile, packageMappings }, options, visitState) => {
+    await logCommandInfoAndTime('Creating api types', 'Created api types', [false], async () => {
+        const { userSessionType, sessionServicesType } = await getPikkuFilesAndMethods(visitState, packageMappings, typesFile, options, { userSessionType: true, sessionServiceType: true });
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type);
+        await writeFileInDir(typesFile, content);
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
+        'rootDir',
+        'routeDirectories',
+        'typesDeclarationFile',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuRoutes(cliConfig, visitState);
+}
+export const functionTypes = (program) => {
+    program
+        .command('types')
+        .description('Generate the core API')
+        .option('-ct | --pikku-config-type', 'The type of your pikku config object')
+        .option('-ss | --singleton-services-factory-type', 'The type of your singleton services factory')
+        .option('-se | --session-services-factory-type', 'The type of your session services factory')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-nextjs.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+import { PikkuCLIOptions } from '../src/utils.js';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuNext: ({ nextJSfile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, }: PikkuCLIConfig, visitState: InspectorState, options: PikkuCLIOptions) => Promise<boolean>;
+export declare const action: (options: PikkuCLIOptions) => Promise<void>;
+export declare const nextjs: (program: Command) => void;