@rvoh/psychic 3.0.1 → 3.0.3

package/dist/cjs/src/bin/helpers/printControllerHierarchy.js

@@ -0,0 +1,168 @@
+import colors from 'yoctocolors';
+import PsychicController from '../../controller/index.js';
+import PsychicApp from '../../psychic-app/index.js';
+const ROOT_CHILD_INDENT = 5;
+const MIN_DASHES = 2;
+export default function printControllerHierarchy(controllersPath) {
+    const lines = controllerHierarchyLines(controllersPath);
+    for (const line of lines) {
+        console.log(line);
+    }
+}
+export function resolveControllerClasses(controllersPath) {
+    const psychicApp = PsychicApp.getOrFail();
+    const resolvedPath = controllersPath ?? psychicApp.paths.controllers;
+    const allControllers = psychicApp.controllers;
+    const controllerClasses = Object.values(allControllers).filter(ctrl => {
+        return ctrl.globalName.startsWith(globalPrefixFromPath(resolvedPath, psychicApp.paths.controllers));
+    });
+    return { controllerClasses, resolvedPath };
+}
+export function controllerHierarchyLines(controllersPath) {
+    const { controllerClasses, resolvedPath } = resolveControllerClasses(controllersPath);
+    const childrenMap = buildChildrenMap(controllerClasses);
+    const roots = controllerClasses.filter(ctrl => !controllerClasses.some(other => other !== ctrl && ctrl.prototype instanceof other));
+    if (roots.length === 0) {
+        return ['No controllers found.'];
+    }
+    const lines = [];
+    for (const root of roots) {
+        collectTreeLines(root, childrenMap, { depth: 0, displayColumn: 0, strippedPrefix: '', baseIndent: 0 }, lines, resolvedPath);
+    }
+    return lines;
+}
+export function controllerHierarchyViolations(controllersPath) {
+    const { controllerClasses, resolvedPath } = resolveControllerClasses(controllersPath);
+    const violations = [];
+    for (const ctrl of controllerClasses) {
+        const parentClass = Object.getPrototypeOf(ctrl);
+        if (parentClass === PsychicController)
+            continue;
+        const violation = hierarchyViolation(ctrl.globalName, parentClass.globalName, resolvedPath);
+        if (violation) {
+            violations.push(violation);
+        }
+    }
+    return violations;
+}
+export function buildChildrenMap(controllerClasses) {
+    const childrenMap = new Map();
+    for (const ctrl of controllerClasses) {
+        const parent = Object.getPrototypeOf(ctrl);
+        if (!childrenMap.has(parent)) {
+            childrenMap.set(parent, []);
+        }
+        childrenMap.get(parent).push(ctrl);
+    }
+    return childrenMap;
+}
+export function controllerTreeLine(displayedName, depth, displayColumn, baseIndent) {
+    if (depth === 0) {
+        return colors.cyan(displayedName);
+    }
+    const numDashes = Math.max(MIN_DASHES, displayColumn - baseIndent - 2);
+    const indentation = ' '.repeat(baseIndent);
+    const dashes = '─'.repeat(numDashes);
+    return `${indentation}└${dashes} ${colors.cyan(displayedName)}`;
+}
+/**
+ * Computes the actual column where the name starts on screen,
+ * accounting for MIN_DASHES potentially pushing the name further right.
+ */
+export function actualDisplayColumn(displayColumn, depth, baseIndent) {
+    if (depth === 0)
+        return displayColumn;
+    const numDashes = Math.max(MIN_DASHES, displayColumn - baseIndent - 2);
+    return baseIndent + numDashes + 2;
+}
+export function sharedDirPrefix(a, b) {
+    const aParts = a.split('/');
+    const bParts = b.split('/');
+    let shared = '';
+    for (let i = 0; i < Math.min(aParts.length, bParts.length); i++) {
+        if (aParts[i] === bParts[i]) {
+            shared += aParts[i] + '/';
+        }
+        else {
+            break;
+        }
+    }
+    return shared;
+}
+export function globalPrefixFromPath(path, defaultControllersPath) {
+    if (path === defaultControllersPath)
+        return 'controllers/';
+    const normalized = path.replace(/\/$/, '');
+    const defaultNormalized = defaultControllersPath.replace(/\/$/, '');
+    if (normalized.startsWith(defaultNormalized + '/')) {
+        const suffix = normalized.slice(defaultNormalized.length + 1);
+        return `controllers/${suffix}/`;
+    }
+    return 'controllers/';
+}
+/**
+ * Returns the directory portion of a globalName.
+ * e.g. "controllers/Admin/AuthedController" -> "controllers/Admin/"
+ *      "controllers/ApplicationController" -> "controllers/"
+ */
+export function globalNameDir(globalName) {
+    const lastSlash = globalName.lastIndexOf('/');
+    if (lastSlash === -1)
+        return '';
+    return globalName.slice(0, lastSlash + 1);
+}
+/**
+ * Returns the parent directory of a directory path.
+ * e.g. "controllers/Admin/" -> "controllers/"
+ *      "controllers/" -> ""
+ */
+export function parentOfDir(dir) {
+    const withoutTrailing = dir.slice(0, -1);
+    const lastSlash = withoutTrailing.lastIndexOf('/');
+    if (lastSlash === -1)
+        return '';
+    return withoutTrailing.slice(0, lastSlash + 1);
+}
+/**
+ * Checks whether a child controller violates the hierarchy convention.
+ * A controller should extend a controller in the same directory or the parent directory.
+ * Returns a warning message string if violated, or null if OK.
+ */
+export function hierarchyViolation(childGlobalName, parentGlobalName, controllersPath) {
+    const childDir = globalNameDir(childGlobalName);
+    const parentControllerDir = globalNameDir(parentGlobalName);
+    if (childDir === parentControllerDir || parentOfDir(childDir) === parentControllerDir) {
+        return null;
+    }
+    const childFilePath = controllersPath + '/' + childGlobalName.replace(/^controllers\//, '') + '.ts';
+    return `[hierarchy violation: ${childFilePath} should extend a BaseController at its same level]`;
+}
+function collectTreeLines(controller, childrenMap, { depth, displayColumn, strippedPrefix, baseIndent, }, lines, controllersPath) {
+    const displayedName = controller.globalName.slice(strippedPrefix.length);
+    lines.push(controllerTreeLine(displayedName, depth, displayColumn, baseIndent));
+    // The actual column where the name appears on screen (may differ from displayColumn
+    // when MIN_DASHES pushes the name further right)
+    const effectiveDisplayColumn = actualDisplayColumn(displayColumn, depth, baseIndent);
+    if (depth > 0) {
+        const parentClass = Object.getPrototypeOf(controller);
+        if (parentClass !== PsychicController) {
+            const violation = hierarchyViolation(controller.globalName, parentClass.globalName, controllersPath);
+            if (violation) {
+                const warningIndent = ' '.repeat(effectiveDisplayColumn);
+                lines.push(warningIndent + colors.yellow(violation));
+            }
+        }
+    }
+    const childBaseIndent = depth === 0 ? ROOT_CHILD_INDENT : effectiveDisplayColumn - 1;
+    const children = childrenMap.get(controller) ?? [];
+    for (const child of children) {
+        const shared = sharedDirPrefix(controller.globalName, child.globalName);
+        const childDisplayColumn = effectiveDisplayColumn + shared.length - strippedPrefix.length;
+        collectTreeLines(child, childrenMap, {
+            depth: depth + 1,
+            displayColumn: childDisplayColumn,
+            strippedPrefix: shared,
+            baseIndent: childBaseIndent,
+        }, lines, controllersPath);
+    }
+}

package/dist/cjs/src/bin/index.js

@@ -10,6 +10,7 @@ import PsychicApp from '../psychic-app/index.js';
 import enumsFileStr from './helpers/enumsFileStr.js';
 import generateRouteTypes from './helpers/generateRouteTypes.js';
 import { OpenApiSpecDiff } from './helpers/OpenApiSpecDiff.js';
+import printControllerHierarchy, { controllerHierarchyViolations, } from './helpers/printControllerHierarchy.js';
 import printRoutes from './helpers/printRoutes.js';
 export { BreakingChangesDetectedInOpenApiSpecError } from './helpers/OpenApiSpecDiff.js';
 export default class PsychicBin {
@@ -26,6 +27,12 @@ export default class PsychicBin {
     static printRoutes() {
         printRoutes();
     }
+    static printControllerHierarchy(controllersPath) {
+        printControllerHierarchy(controllersPath);
+    }
+    static controllerHierarchyViolations(controllersPath) {
+        return controllerHierarchyViolations(controllersPath);
+    }
     static async sync({ bypassDreamSync = false, schemaOnly = false, } = {}) {
         if (!bypassDreamSync)
             await DreamBin.sync(() => { }, { schemaOnly });
@@ -39,27 +46,19 @@ export default class PsychicBin {
         await DreamCLI.spawn(psychicApp.psyCmd('post-sync'), {
             onStdout: message => {
                 DreamCLI.logger.logContinueProgress(`[post-sync]` + ' ' + message, {
-                    logPrefixColor: 'cyan',
+                    logPrefixColor: 'greenBright',
                 });
             },
         });
         DreamCLI.logger.logEndProgress();
     }
     static async postSync() {
-        try {
-            await this.syncOpenapiJson();
-            await this.runCliHooksAndUpdatePsychicTypesFileWithOutput();
-            await this.syncOpenapiTypescriptFiles();
-        }
-        catch (error) {
-            console.error(error);
-            await CliFileWriter.revert();
-        }
+        await this.syncOpenapiJson();
+        await this.runCliHooksAndUpdatePsychicTypesFileWithOutput();
+        await this.syncOpenapiTypescriptFiles();
     }
     static async syncTypes() {
-        await DreamCLI.logger.logProgress(`syncing types/psychic.ts...`, async () => {
-            await new ASTPsychicTypesBuilder().build();
-        });
+        await new ASTPsychicTypesBuilder().build();
     }
     static openapiDiff() {
         const psychicApp = PsychicApp.getOrFail();

package/dist/cjs/src/cli/index.js

@@ -4,7 +4,10 @@ import generateController from '../generate/controller.js';
 import generateSyncEnumsInitializer from '../generate/initializer/syncEnums.js';
 import generateSyncOpenapiTypescriptInitializer from '../generate/initializer/syncOpenapiTypescript.js';
 import generateOpenapiReduxBindings from '../generate/openapi/reduxBindings.js';
+import generateOpenapiZustandBindings from '../generate/openapi/zustandBindings.js';
 import generateResource from '../generate/resource.js';
+import colorize from './helpers/colorize.js';
+import PsychicLogos from './helpers/PsychicLogos.js';
 import Watcher from '../watcher/Watcher.js';
 const INDENT = '                  ';
 const baseColumnsWithTypesDescription = `space separated snake-case (except for belongs_to model name) properties like this:
@@ -67,6 +70,22 @@ ${INDENT}        include the fully qualified model name, e.g., if the Coach mode
 ${INDENT}          Health/Coach:belongs_to`;
 export default class PsychicCLI {
     static provide(program, { initializePsychicApp, seedDb, }) {
+        program.hook('preAction', (_thisCommand, actionCommand) => {
+            const cmdName = actionCommand.name();
+            switch (cmdName) {
+                case 'post-sync':
+                    return;
+                default:
+                    DreamCLI.logger.log(colorize(PsychicLogos.asciiLogo(), { color: 'greenBright' }), { logPrefix: '' });
+                    DreamCLI.logger.log('\n', { logPrefix: '' });
+                    DreamCLI.logger.log(colorize(' ', { color: 'green' }) +
+                        colorize(' ' + cmdName + ' ', { color: 'black', bgColor: 'bgGreen' }) +
+                        '\n', {
+                        logPrefix: '',
+                    });
+                    DreamCLI.logger.log(colorize('⭣⭣⭣', { color: 'green' }) + '\n', { logPrefix: ' ' });
+            }
+        });
         DreamCLI.generateDreamCli(program, {
             initializeDreamApp: initializePsychicApp,
             seedDb,
@@ -78,14 +97,14 @@ export default class PsychicCLI {
             .command('generate:resource')
             .alias('g:resource')
             .description('Generates a Dream model with corresponding spec factory, serializer, migration, and controller with the inheritance chain leading to that controller, with fleshed out specs for each resourceful action in the controller.')
-            .option('--singular', 'generates a "resource" route instead of "resources", along with the necessary controller and spec changes')
+            .option('--singular', 'generates a "resource" route instead of "resources", along with the necessary controller and spec changes', false)
             .option('--only <onlyActions>', `comma separated list of resourceful endpionts (e.g. "--only=create,show"); any of:
                               - index
                               - create
                               - show
                               - update
                               - delete`)
-            .option('--sti-base-serializer', 'omits the serializer from the dream model, but does create the serializer so it can be extended by STI children')
+            .option('--sti-base-serializer', 'creates a generically typed base serializer that includes the child type in the output so consuming applications can determine shape based on type', false)
             .option('--owning-model <modelName>', 'the model class of the object that `associationQuery`/`createAssociation` will be performed on in the created controller and spec (e.g., "Host", "Guest", "Ticketing/Ticket"). Defaults to the current user for non-admin/internal namespaced controllers. For admin/internal namespaced controllers, this defaults to null, meaning every admin/internal user can access the model.')
             .option('--connection-name <connectionName>', 'the name of the db connection you would like to use for your model. Defaults to "default"', 'default')
             .option('--model-name <modelName>', 'explicit model class name to use instead of the auto-generated one (e.g. --model-name=Kitchen for Room/Kitchen)')
@@ -146,6 +165,26 @@ export default class PsychicCLI {
             });
             process.exit();
         });
+        program
+            .command('setup:sync:openapi-zustand')
+            .description('Generates typed API functions from an openapi file using @hey-api/openapi-ts, for use with Zustand or any other state manager.')
+            .option('--schema-file <schemaFile>', 'the path from your api root to the openapi file you wish to use to generate your schema, i.e. ./src/openapi/openapi.json')
+            .option('--output-dir <outputDir>', 'the directory where @hey-api/openapi-ts will generate typed API functions and types, i.e. ../client/app/api/myBackendApi')
+            .option('--client-config-file <clientConfigFile>', 'the path to the client configuration file that configures @hey-api/client-fetch with base URL and credentials, i.e. ../client/app/api/myBackendApi/client.ts')
+            .option('--export-name <exportName>', 'the camelCased name to use for your exported api, i.e. myBackendApi')
+            .action(async ({ schemaFile, outputDir, clientConfigFile, exportName, }) => {
+            await initializePsychicApp({
+                bypassDreamIntegrityChecks: true,
+                bypassDbConnectionsDuringInit: true,
+            });
+            await generateOpenapiZustandBindings({
+                exportName,
+                schemaFile,
+                outputDir,
+                clientConfigFile,
+            });
+            process.exit();
+        });
         program
             .command('setup:sync:openapi-typescript')
             .description('Generates an initializer in your app for converting one of your openapi files to typescript.')
@@ -160,6 +199,31 @@ export default class PsychicCLI {
             await generateSyncOpenapiTypescriptInitializer(openapiFilepath, outfile, initializerName);
             process.exit();
         });
+        program
+            .command('inspect:controller-hierarchy')
+            .alias('i:controller-hierarchy')
+            .description('Displays the inheritance hierarchy of all PsychicController classes in the project.')
+            .argument('[path]', 'the controllers directory to scan (defaults to the configured controllers path)')
+            .action(async (controllersPath) => {
+            await initializePsychicApp();
+            PsychicBin.printControllerHierarchy(controllersPath);
+            process.exit();
+        });
+        program
+            .command('check:controller-hierarchy')
+            .description('Checks that all controllers extend a controller in the same or parent directory. Exits with an error if any violations are found.')
+            .argument('[path]', 'the controllers directory to scan (defaults to the configured controllers path)')
+            .action(async (controllersPath) => {
+            await initializePsychicApp();
+            const violations = PsychicBin.controllerHierarchyViolations(controllersPath);
+            if (violations.length > 0) {
+                for (const violation of violations) {
+                    console.error(violation);
+                }
+                process.exit(1);
+            }
+            process.exit();
+        });
         program
             .command('routes')
             .description('Prints a list of routes defined by the application, including path arguments and the controller/action reached by the route.')
@@ -171,8 +235,8 @@ export default class PsychicCLI {
         program
             .command('sync')
             .description("Generates types from the current state of the database. Generates OpenAPI specs from @OpenAPI decorated controller actions. Additional sync actions may be customized with `on('cli:sync', async () => {})` in conf/app.ts or in an initializer in `conf/initializers/`.")
-            .option('--ignore-errors')
-            .option('--schema-only')
+            .option('--ignore-errors', 'ignore integrity checks and continue sync', false)
+            .option('--schema-only', 'sync database schema types only', false)
             .action(async (options) => {
             await initializePsychicApp({ bypassDreamIntegrityChecks: options.ignoreErrors || options.schemaOnly });
             await PsychicBin.sync(options);
@@ -211,7 +275,7 @@ export default class PsychicCLI {
         program
             .command('diff:openapi')
             .description('compares the current branch open api spec file(s) with the main/master/head branch open api spec file(s)')
-            .option('-f', '--fail-on-breaking', 'fail on spec changes that are breaking')
+            .option('-f, --fail-on-breaking', 'fail on spec changes that are breaking', false)
             .action(async (options) => {
             await initializePsychicApp();
             try {

package/dist/cjs/src/generate/helpers/reduxBindings/writeInitializer.js

@@ -30,15 +30,15 @@ import AppEnv from '../../AppEnv.js'
 export default function initialize${pascalized}(psy: PsychicApp) {
   psy.on('cli:sync', async () => {
     if (AppEnv.isDevelopmentOrTest) {
-      DreamCLI.logger.logStartProgress(\`[${camelized}] syncing...\`)
-      await DreamCLI.spawn('npx @rtk-query/codegen-openapi ${filePath}', {
-        onStdout: message => {
-          DreamCLI.logger.logContinueProgress(\`[${camelized}]\` + ' ' + message, {
-            logPrefixColor: 'green',
-          })
-        },
+      await DreamCLI.logger.logProgress(\`[${camelized}] syncing...\`, async () => {
+        await DreamCLI.spawn('npx @rtk-query/codegen-openapi ${filePath}', {
+          onStdout: message => {
+            DreamCLI.logger.logContinueProgress(\`[${camelized}]\` + ' ' + message, {
+              logPrefixColor: 'green',
+            })
+          },
+        })
       })
-      DreamCLI.logger.logEndProgress()
     }
   })
 }\

package/dist/cjs/src/generate/helpers/syncOpenapiTypescript/generateInitializer.js

@@ -23,9 +23,9 @@ import AppEnv from '../AppEnv.js'
 export default (psy: PsychicApp) => {
   psy.on('cli:sync', async () => {
     if (AppEnv.isDevelopmentOrTest) {
-      DreamCLI.logger.logStartProgress(\`[${hyphenized}] extracting types from ${openapiFilepath} to ${outfile}...\`)
-      await DreamCLI.spawn('npx openapi-typescript ${openapiFilepath} -o ${outfile}')
-      DreamCLI.logger.logEndProgress()
+      await DreamCLI.logger.logProgress(\`[${hyphenized}] extracting types from ${openapiFilepath} to ${outfile}...\`, async () => {
+        await DreamCLI.spawn('npx openapi-typescript ${openapiFilepath} -o ${outfile}')
+      })
     }
   })
 }\

package/dist/cjs/src/generate/helpers/zustandBindings/printFinalStepsMessage.js

@@ -0,0 +1,47 @@
+import { DreamCLI } from '@rvoh/dream/system';
+import colorize from '../../../cli/helpers/colorize.js';
+export default function printFinalStepsMessage(opts) {
+    const importLine = colorize(`+ import '${opts.clientConfigFile}'`, { color: 'green' });
+    const sdkImportLine = colorize(`+ import { getAdminCities, postAdminCities } from '${opts.outputDir}/sdk.gen'`, {
+        color: 'green',
+    });
+    const usageLine = colorize(`  const { data, error } = await getAdminCities()`, {
+        color: 'green',
+    });
+    const zustandLine = colorize(`  const { data } = await getAdminCities()
+    set({ cities: data?.results })`, { color: 'green' });
+    DreamCLI.logger.log(`
+Finished generating @hey-api/openapi-ts bindings for your application.
+
+First, you will need to be sure to sync, so that the typed API functions
+are generated from your openapi schema:
+
+  pnpm psy sync
+
+This will generate typed API functions and types in ${opts.outputDir}/
+
+To use the generated API, first import the client config at your app's
+entry point to configure the base URL and credentials:
+
+${importLine}
+
+Then import and use the generated typed functions anywhere:
+
+${sdkImportLine}
+
+// all functions are fully typed with request params and response types
+${usageLine}
+
+To use with a Zustand store:
+
+import { create } from 'zustand'
+${sdkImportLine}
+
+const useCitiesStore = create((set) => ({
+  cities: [],
+  fetchCities: async () => {
+${zustandLine}
+  },
+}))
+`, { logPrefix: '' });
+}

package/dist/cjs/src/generate/helpers/zustandBindings/promptForOptions.js

@@ -0,0 +1,61 @@
+import { camelize } from '@rvoh/dream/utils';
+import cliPrompt from '../../../cli/helpers/cli-prompt.js';
+import PsychicApp from '../../../psychic-app/index.js';
+export default async function promptForOptions(options) {
+    if (!options.schemaFile) {
+        const defaultVal = './src/openapi/openapi.json';
+        const answer = await cliPrompt(`\
+What would you like the schemaFile to be?
+
+The schemaFile is the openapi file that @hey-api/openapi-ts will read to produce
+all of its typed API functions and types. If not provided, it will default to
+
+  ${defaultVal}
+`);
+        options.schemaFile = answer || defaultVal;
+    }
+    if (!options.exportName) {
+        const defaultVal = `${camelize(PsychicApp.getOrFail().appName)}Api`;
+        const answer = await cliPrompt(`\
+What would you like the exportName to be?
+
+The exportName is used to name the generated API output. It will be used to name
+the initializer and config files. We recommend naming it something like the name
+of your app, i.e.
+
+  ${defaultVal}
+`);
+        options.exportName = answer || defaultVal;
+    }
+    if (!options.outputDir) {
+        const defaultVal = `../client/app/api/${camelize(options.exportName)}`;
+        const answer = await cliPrompt(`\
+What would you like the outputDir to be?
+
+The outputDir is the directory where @hey-api/openapi-ts will generate the typed
+API functions and types. It will contain files like types.gen.ts and sdk.gen.ts.
+If not provided, it will default to:
+
+  ${defaultVal}
+`);
+        options.outputDir = answer || defaultVal;
+    }
+    if (!options.clientConfigFile) {
+        const defaultVal = `../client/app/api/${camelize(options.exportName)}/client.ts`;
+        const answer = await cliPrompt(`\
+What would you like the path to your clientConfigFile to be?
+
+The clientConfigFile specifies where to generate the client configuration file
+that configures @hey-api/client-fetch with your base URL, credentials, and
+other request options.
+
+We expect you to provide this path with the api root in mind, so you will need
+to consider how to travel to the desired filepath from within your psychic
+project, i.e.
+
+  ${defaultVal}
+`);
+        options.clientConfigFile = answer || defaultVal;
+    }
+    return options;
+}

package/dist/cjs/src/generate/helpers/zustandBindings/writeClientConfigFile.js

@@ -0,0 +1,43 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export default async function writeClientConfigFile({ clientConfigFile }) {
+    const destDir = path.dirname(clientConfigFile);
+    try {
+        await fs.access(clientConfigFile);
+        return; // early return if the file already exists
+    }
+    catch {
+        // noop
+    }
+    try {
+        await fs.access(destDir);
+    }
+    catch {
+        await fs.mkdir(destDir, { recursive: true });
+    }
+    const contents = `\
+import { client } from '@hey-api/client-fetch'
+
+function baseUrl() {
+  // add custom code here for determining your application's baseUrl
+  // this would generally be something different, depending on if you
+  // are in dev/test/production environments. For dev, you might want
+  // http://localhost:7777, while test may be http://localhost:7778, or
+  // some other port, depending on how you have your spec hooks configured.
+  // for production, it should be the real host for your application, i.e.
+  // https://myapi.com
+
+  return 'http://localhost:7777'
+}
+
+client.setConfig({
+  baseUrl: baseUrl(),
+  credentials: 'include',
+
+  // you can customize headers here, for example to add auth tokens:
+  // headers: {
+  //   Authorization: \`Bearer \${getToken()}\`,
+  // },
+})`;
+    await fs.writeFile(clientConfigFile, contents);
+}

package/dist/cjs/src/generate/helpers/zustandBindings/writeInitializer.js

@@ -0,0 +1,46 @@
+import { camelize, pascalize } from '@rvoh/dream/utils';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import psychicPath from '../../../helpers/path/psychicPath.js';
+export default async function writeInitializer({ exportName, schemaFile, outputDir, }) {
+    const pascalized = pascalize(exportName);
+    const camelized = camelize(exportName);
+    const destDir = path.join(psychicPath('conf'), 'initializers', 'openapi');
+    const initializerFilename = `${camelized}.ts`;
+    const initializerPath = path.join(destDir, initializerFilename);
+    try {
+        await fs.access(initializerPath);
+        return; // early return if the file already exists
+    }
+    catch {
+        // noop
+    }
+    try {
+        await fs.access(destDir);
+    }
+    catch {
+        await fs.mkdir(destDir, { recursive: true });
+    }
+    const contents = `\
+import { DreamCLI } from '@rvoh/dream/system'
+import { PsychicApp } from '@rvoh/psychic'
+import AppEnv from '../../AppEnv.js'
+
+export default function initialize${pascalized}(psy: PsychicApp) {
+  psy.on('cli:sync', async () => {
+    if (AppEnv.isDevelopmentOrTest) {
+      await DreamCLI.logger.logProgress(\`[${camelized}] syncing...\`, async () => {
+        await DreamCLI.spawn('npx @hey-api/openapi-ts -i ${schemaFile} -o ${outputDir}', {
+          onStdout: message => {
+            DreamCLI.logger.logContinueProgress(\`[${camelized}]\` + ' ' + message, {
+              logPrefixColor: 'green',
+            })
+          },
+        })
+      })
+    }
+  })
+}\
+`;
+    await fs.writeFile(initializerPath, contents);
+}

package/dist/cjs/src/generate/initializer/syncEnums.js

@@ -29,9 +29,9 @@ import AppEnv from '../AppEnv.js'
 export default function ${camelized}(psy: PsychicApp) {
   psy.on('cli:sync', async () => {
     if (AppEnv.isDevelopmentOrTest) {
-      DreamCLI.logger.logStartProgress(\`[${camelized}] syncing enums to ${outfile}...\`)
-      await PsychicBin.syncClientEnums('${outfile}')
-      DreamCLI.logger.logEndProgress()
+      await DreamCLI.logger.logProgress(\`[${camelized}] syncing enums to ${outfile}...\`, async () => {
+        await PsychicBin.syncClientEnums('${outfile}')
+      })
     }
   })
 }\

package/dist/cjs/src/generate/openapi/zustandBindings.js

@@ -0,0 +1,27 @@
+import { DreamCLI } from '@rvoh/dream/system';
+import PackageManager from '../../cli/helpers/PackageManager.js';
+import printFinalStepsMessage from '../helpers/zustandBindings/printFinalStepsMessage.js';
+import promptForOptions from '../helpers/zustandBindings/promptForOptions.js';
+import writeClientConfigFile from '../helpers/zustandBindings/writeClientConfigFile.js';
+import writeInitializer from '../helpers/zustandBindings/writeInitializer.js';
+/**
+ * @internal
+ *
+ * used by the psychic CLI to generate boilerplate
+ * that can be used to integrate a specific openapi.json
+ * file with a client using @hey-api/openapi-ts.
+ *
+ * * generates the client config file if it does not exist
+ * * generates an initializer, which taps into the sync hooks
+ *   to automatically run the @hey-api/openapi-ts CLI util
+ * * prints a helpful message, instructing devs on the final
+ *   steps for using the generated typed API functions
+ *   within their client application.
+ */
+export default async function generateOpenapiZustandBindings(options = {}) {
+    const opts = await promptForOptions(options);
+    await writeClientConfigFile(opts);
+    await writeInitializer(opts);
+    await DreamCLI.spawn(PackageManager.add(['@hey-api/openapi-ts', '@hey-api/client-fetch'], { dev: true }));
+    printFinalStepsMessage(opts);
+}