@rvoh/psychic 3.0.0-alpha.7 → 3.0.0-alpha.8

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

@@ -4,6 +4,7 @@ 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 Watcher from '../watcher/Watcher.js';
 const INDENT = '                  ';
@@ -85,6 +86,7 @@ export default class PsychicCLI {
             .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('--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") (simply to save time making changes to the generated code). Defaults to User')
             .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)')
             .argument('<path>', 'URL path from root domain. Specify nesting resource with `{}`, e.g.: `tickets/{}/comments`')
             .argument('<modelName>', 'the name of the model to create, e.g. Post or Settings/CommunicationPreferences')
             .argument('[columnsWithTypes...]', columnsWithTypesDescription)
@@ -142,6 +144,26 @@ export default class PsychicCLI {
             });
             process.exit();
         });
+        program
+            .command('setup:sync:openapi-zustand')
+            .description('Generates openapi zustand bindings using openapi-fetch to connect one of your openapi files to one of your clients.')
+            .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('--export-name <exportName>', 'the camelCased name to use for your exported api client, i.e. myBackendApi')
+            .option('--output-dir <outputDir>', 'the path to the directory where the generated api client and types files will be written, i.e. ../client/src/api')
+            .option('--types-file <typesFile>', 'the path to the file that will contain your generated openapi TypeScript type definitions, i.e. ../client/src/api/myBackendApi.types.d.ts')
+            .action(async ({ schemaFile, exportName, outputDir, typesFile, }) => {
+            await initializePsychicApp({
+                bypassDreamIntegrityChecks: true,
+                bypassDbConnectionsDuringInit: true,
+            });
+            await generateOpenapiZustandBindings({
+                exportName,
+                schemaFile,
+                outputDir,
+                typesFile,
+            });
+            process.exit();
+        });
         program
             .command('setup:sync:openapi-typescript')
             .description('Generates an initializer in your app for converting one of your openapi files to typescript.')

package/dist/cjs/src/generate/controller.js

@@ -19,11 +19,12 @@ export default async function generateController({ fullyQualifiedControllerName,
     fullyQualifiedControllerName = fullyQualifiedControllerName.replace(pathParamRegexp, '/');
     const allControllerNameParts = fullyQualifiedControllerName.split('/');
     const forAdmin = allControllerNameParts[0] === 'Admin';
-    const controllerNameParts = forAdmin ? [allControllerNameParts.shift()] : [];
+    const forInternal = allControllerNameParts[0] === 'Internal';
+    const controllerNameParts = (forAdmin || forInternal) ? [allControllerNameParts.shift()] : [];
     for (let index = 0; index < allControllerNameParts.length; index++) {
-        if (controllerNameParts.length > (forAdmin ? 1 : 0)) {
+        if (controllerNameParts.length > ((forAdmin || forInternal) ? 1 : 0)) {
             // Write the ancestor controller
-            const [baseAncestorName, baseAncestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, forAdmin, { forBaseController: true });
+            const [baseAncestorName, baseAncestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, forAdmin, forInternal, { forBaseController: true });
             if (baseAncestorName === undefined)
                 throw new UnexpectedUndefined();
             if (baseAncestorImportStatement === undefined)
@@ -38,6 +39,7 @@ export default async function generateController({ fullyQualifiedControllerName,
                     fullyQualifiedControllerName: baseControllerName,
                     omitOpenApi: true,
                     forAdmin,
+                    forInternal,
                     singular,
                 }));
             }
@@ -47,7 +49,7 @@ export default async function generateController({ fullyQualifiedControllerName,
             controllerNameParts.push(namedPart);
     }
     // Write the controller
-    const [ancestorName, ancestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, forAdmin, {
+    const [ancestorName, ancestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, forAdmin, forInternal, {
         forBaseController: false,
     });
     if (ancestorName === undefined)
@@ -66,6 +68,7 @@ export default async function generateController({ fullyQualifiedControllerName,
             actions,
             owningModel,
             forAdmin,
+            forInternal,
             singular,
         }));
     }
@@ -86,29 +89,35 @@ export default async function generateController({ fullyQualifiedControllerName,
         resourceSpecs,
         owningModel,
         forAdmin,
+        forInternal,
         singular,
         actions,
     });
 }
-function baseAncestorNameAndImport(controllerNameParts, forAdmin, { forBaseController }) {
+function baseAncestorNameAndImport(controllerNameParts, forAdmin, forInternal, { forBaseController }) {
     const maybeAncestorNameForBase = `${controllerNameParts.slice(0, controllerNameParts.length - 1).join('')}BaseController`;
     const dotFiles = forBaseController ? '..' : '.';
-    return controllerNameParts.length === (forAdmin ? 2 : 1)
+    return controllerNameParts.length === ((forAdmin || forInternal) ? 2 : 1)
         ? forAdmin
             ? [
                 `AdminAuthedController`,
                 `import AdminAuthedController from '${dotFiles}/${addImportSuffix('AuthedController.js')}'`,
             ]
-            : [
-                `AuthedController`,
-                `import AuthedController from '${dotFiles}/${addImportSuffix('AuthedController.js')}'`,
-            ]
+            : forInternal
+                ? [
+                    `InternalAuthedController`,
+                    `import InternalAuthedController from '${dotFiles}/${addImportSuffix('AuthedController.js')}'`,
+                ]
+                : [
+                    `AuthedController`,
+                    `import AuthedController from '${dotFiles}/${addImportSuffix('AuthedController.js')}'`,
+                ]
         : [
             maybeAncestorNameForBase,
             `import ${maybeAncestorNameForBase} from '${dotFiles}/${addImportSuffix('BaseController.js')}'`,
         ];
 }
-async function generateControllerSpec({ fullyQualifiedControllerName, route, fullyQualifiedModelName, columnsWithTypes, resourceSpecs, owningModel, forAdmin, singular, actions, }) {
+async function generateControllerSpec({ fullyQualifiedControllerName, route, fullyQualifiedModelName, columnsWithTypes, resourceSpecs, owningModel, forAdmin, forInternal, singular, actions, }) {
     const { relFilePath, absDirPath, absFilePath } = psychicFileAndDirPaths(psychicPath('controllerSpecs'), fullyQualifiedControllerName + `.spec.ts`);
     try {
         console.log(`generating controller spec: ${relFilePath}`);
@@ -121,6 +130,7 @@ async function generateControllerSpec({ fullyQualifiedControllerName, route, ful
                 columnsWithTypes,
                 owningModel,
                 forAdmin,
+                forInternal,
                 singular,
                 actions,
             })

package/dist/cjs/src/generate/helpers/addResourceToRoutes.js

@@ -13,6 +13,12 @@ export default async function addResourceToRoutes(route, options) {
         if (fsSync.existsSync(adminRoutesFilePath))
             routesFilePath = adminRoutesFilePath;
     }
+    const internalRouteRegexp = /^\/?internal/;
+    if (internalRouteRegexp.test(route)) {
+        const internalRoutesFilePath = routesFilePath.replace(/\.ts$/, '.internal.ts');
+        if (fsSync.existsSync(internalRoutesFilePath))
+            routesFilePath = internalRoutesFilePath;
+    }
     let routes = (await fs.readFile(routesFilePath)).toString();
     const results = addResourceToRoutes_routeToRegexAndReplacements(routes, route, options);
     routes = results.routes;

package/dist/cjs/src/generate/helpers/generateControllerContent.js

@@ -1,7 +1,7 @@
 import { DreamApp } from '@rvoh/dream';
 import { camelize, hyphenize } from '@rvoh/dream/utils';
 import pluralize from 'pluralize-esm';
-export default function generateControllerContent({ ancestorName, ancestorImportStatement, fullyQualifiedControllerName, fullyQualifiedModelName, actions = [], omitOpenApi = false, owningModel, forAdmin, singular, }) {
+export default function generateControllerContent({ ancestorName, ancestorImportStatement, fullyQualifiedControllerName, fullyQualifiedModelName, actions = [], omitOpenApi = false, owningModel, forAdmin, forInternal = false, singular, }) {
     fullyQualifiedControllerName = DreamApp.system.standardizeFullyQualifiedModelName(fullyQualifiedControllerName);
     const additionalImports = [];
     const controllerClassName = DreamApp.system.globalClassNameFromFullyQualifiedModelName(fullyQualifiedControllerName);
@@ -22,8 +22,12 @@ export default function generateControllerContent({ ancestorName, ancestorImport
     const defaultOpenapiSerializerKeyProperty = forAdmin
         ? `
     serializerKey: 'admin',`
-        : '';
-    const loadQueryBase = forAdmin
+        : forInternal
+            ? `
+    serializerKey: 'internal',`
+            : '';
+    const useDirectModelAccess = (forAdmin || forInternal) && !owningModel;
+    const loadQueryBase = useDirectModelAccess
         ? (modelClassName ?? 'no-class-name')
         : `this.${owningModelProperty}.associationQuery('${pluralizedModelAttributeName}')`;
     const methodDefs = actions.map(methodName => {
@@ -38,8 +42,8 @@ export default function generateControllerContent({ ancestorName, ancestorImport
     fastJsonStringify: true,
   })
   public async create() {
-    // let ${modelAttributeName} = await ${forAdmin ? `${modelClassName}.create(` : `this.${owningModelProperty}.createAssociation('${pluralizedModelAttributeName}', `}this.paramsFor(${modelClassName}))
-    // if (${modelAttributeName}.isPersisted) ${modelAttributeName} = await ${modelAttributeName}.loadFor('${forAdmin ? 'admin' : 'default'}').execute()
+    // let ${modelAttributeName} = await ${useDirectModelAccess ? `${modelClassName}.create(` : `this.${owningModelProperty}.createAssociation('${pluralizedModelAttributeName}', `}this.paramsFor(${modelClassName}))
+    // if (${modelAttributeName}.isPersisted) ${modelAttributeName} = await ${modelAttributeName}.loadFor('${forAdmin ? 'admin' : forInternal ? 'internal' : 'default'}').execute()
     // this.created(${modelAttributeName})
   }`;
                 else
@@ -60,12 +64,12 @@ export default function generateControllerContent({ ancestorName, ancestorImport
     tags: openApiTags,
     description: 'Paginated index of ${pluralize(modelClassName)}',
     cursorPaginate: true,
-    serializerKey: '${forAdmin ? 'adminSummary' : 'summary'}',
+    serializerKey: '${forAdmin ? 'adminSummary' : forInternal ? 'internalSummary' : 'summary'}',
     fastJsonStringify: true,
   })
   public async index() {
     // const ${pluralizedModelAttributeName} = await ${loadQueryBase}
-    //   .preloadFor('${forAdmin ? 'adminSummary' : 'summary'}')
+    //   .preloadFor('${forAdmin ? 'adminSummary' : forInternal ? 'internalSummary' : 'summary'}')
     //   .cursorPaginate({ cursor: this.castParam('cursor', 'string', { allowNull: true }) })
     // this.ok(${pluralizedModelAttributeName})
   }`;
@@ -76,7 +80,7 @@ export default function generateControllerContent({ ancestorName, ancestorImport
   //   tags: openApiTags,
   //   description: '<tbd>',
   //   many: true,
-  //   serializerKey: '${forAdmin ? 'adminSummary' : 'summary'}',
+  //   serializerKey: '${forAdmin ? 'adminSummary' : forInternal ? 'internalSummary' : 'summary'}',
   //   fastJsonStringify: true,
   // })
   public async index() {
@@ -183,22 +187,22 @@ export default function generateControllerContent({ ancestorName, ancestorImport
 ${omitOpenApi ? '' : openApiImport + '\n'}${ancestorImportStatement}${additionalImports.length ? '\n' + additionalImports.join('\n') : ''}${omitOpenApi ? '' : '\n\n' + openApiTags}
 
 export default class ${controllerClassName} extends ${ancestorName} {
-${methodDefs.join('\n\n')}${modelClassName ? privateMethods(forAdmin, modelClassName, actions, loadQueryBase, singular) : ''}
+${methodDefs.join('\n\n')}${modelClassName ? privateMethods(forAdmin, forInternal, modelClassName, actions, loadQueryBase, singular) : ''}
 }
 `;
 }
-function privateMethods(forAdmin, modelClassName, methods, loadQueryBase, singular) {
+function privateMethods(forAdmin, forInternal, modelClassName, methods, loadQueryBase, singular) {
     const privateMethods = [];
     if (methods.find(methodName => ['show', 'update', 'destroy'].includes(methodName)))
-        privateMethods.push(loadModelStatement(forAdmin, modelClassName, loadQueryBase, singular));
+        privateMethods.push(loadModelStatement(forAdmin, forInternal, modelClassName, loadQueryBase, singular));
     if (!privateMethods.length)
         return '';
     return `\n\n${privateMethods.join('\n\n')}`;
 }
-function loadModelStatement(forAdmin, modelClassName, loadQueryBase, singular) {
+function loadModelStatement(forAdmin, forInternal, modelClassName, loadQueryBase, singular) {
     return `  private async ${camelize(modelClassName)}() {
     // return await ${loadQueryBase}
-    //   .preloadFor('${forAdmin ? 'admin' : 'default'}')
+    //   .preloadFor('${forAdmin ? 'admin' : forInternal ? 'internal' : 'default'}')
     //   ${singular ? '.firstOrFail()' : ".findOrFail(this.castParam('id', 'string'))"}
   }`;
 }

package/dist/cjs/src/generate/helpers/generateResourceControllerSpecContent.js

@@ -22,15 +22,16 @@ function createModelConfiguration(options) {
     const fullyQualifiedModelName = DreamApp.system.standardizeFullyQualifiedModelName(options.fullyQualifiedModelName);
     const modelClassName = DreamApp.system.globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
     const modelVariableName = camelize(modelClassName);
-    const userModelName = options.forAdmin ? 'AdminUser' : 'User';
-    const userVariableName = options.forAdmin ? 'adminUser' : 'user';
+    const userModelName = options.forInternal ? 'InternalUser' : options.forAdmin ? 'AdminUser' : 'User';
+    const userVariableName = options.forInternal ? 'internalUser' : options.forAdmin ? 'adminUser' : 'user';
     const owningModelName = options.owningModel
         ? DreamApp.system.globalClassNameFromFullyQualifiedModelName(options.owningModel)
         : userModelName;
     const owningModelVariableName = options.owningModel
         ? camelize(DreamApp.system.standardizeFullyQualifiedModelName(options.owningModel).split('/').pop())
         : userVariableName;
-    const simpleCreationCommand = `const ${modelVariableName} = await create${modelClassName}(${options.forAdmin ? '' : `{ ${owningModelVariableName} }`})`;
+    const useDirectModelAccess = (options.forAdmin || options.forInternal) && !options.owningModel;
+    const simpleCreationCommand = `const ${modelVariableName} = await create${modelClassName}(${useDirectModelAccess ? '' : `{ ${owningModelVariableName} }`})`;
     return {
         fullyQualifiedModelName,
         modelClassName,
@@ -40,6 +41,7 @@ function createModelConfiguration(options) {
         owningModelName,
         owningModelVariableName,
         simpleCreationCommand,
+        useDirectModelAccess,
     };
 }
 function createActionConfiguration(options) {
@@ -264,7 +266,7 @@ describe('${fullyQualifiedControllerName}', () => {
 function generateIndexActionSpec(options) {
     if (options.actionConfig.omitIndex)
         return '';
-    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, forAdmin } = options;
+    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular } = options;
     const subjectFunctionName = `index${pluralize(modelConfig.modelClassName)}`;
     return `
 
@@ -283,7 +285,7 @@ function generateIndexActionSpec(options) {
           id: ${modelConfig.modelVariableName}.id,
         }),
       ])
-    })${singular || forAdmin
+    })${singular || modelConfig.useDirectModelAccess
         ? ''
         : `
 
@@ -301,7 +303,7 @@ function generateIndexActionSpec(options) {
 function generateShowActionSpec(options) {
     if (options.actionConfig.omitShow)
         return '';
-    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, forAdmin, attributeData } = options;
+    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, attributeData } = options;
     const subjectFunctionName = `show${modelConfig.modelClassName}`;
     const subjectFunction = singular
         ? `
@@ -326,7 +328,7 @@ function generateShowActionSpec(options) {
           id: ${modelConfig.modelVariableName}.id,${attributeData.comparableOriginalAttributeKeyValues.length ? '\n          ' + attributeData.comparableOriginalAttributeKeyValues.join('\n          ') : ''}
         }),
       )
-    })${singular || forAdmin
+    })${singular || modelConfig.useDirectModelAccess
         ? ''
         : `
 
@@ -342,7 +344,7 @@ function generateShowActionSpec(options) {
 function generateCreateActionSpec(options) {
     if (options.actionConfig.omitCreate)
         return '';
-    const { path, pathParams, modelConfig, fullyQualifiedModelName, forAdmin, singular, attributeData } = options;
+    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, attributeData } = options;
     const subjectFunctionName = `create${modelConfig.modelClassName}`;
     const uuidSetup = attributeData.uuidAttributes
         .map(attrName => {
@@ -360,7 +362,7 @@ function generateCreateActionSpec(options) {
         ? `
       const now = DateTime.now()`
         : ''}${uuidSetup || attributeData.dateAttributeIncluded || attributeData.datetimeAttributeIncluded ? '\n' : ''}`;
-    const modelQuery = forAdmin
+    const modelQuery = modelConfig.useDirectModelAccess
         ? `${modelConfig.modelClassName}.firstOrFail()`
         : `${modelConfig.owningModelVariableName}.associationQuery('${singular ? modelConfig.modelVariableName : pluralize(modelConfig.modelVariableName)}').firstOrFail()`;
     return `
@@ -375,7 +377,7 @@ function generateCreateActionSpec(options) {
       })
     }
 
-    it('creates a ${fullyQualifiedModelName}${forAdmin ? '' : ` for this ${modelConfig.owningModelName}`}', async () => {${dateTimeSetup}
+    it('creates a ${fullyQualifiedModelName}${modelConfig.useDirectModelAccess ? '' : ` for this ${modelConfig.owningModelName}`}', async () => {${dateTimeSetup}
       const { body } = await ${subjectFunctionName}({
         ${attributeData.attributeCreationKeyValues.join('\n        ')}
       }, 201)
@@ -393,7 +395,7 @@ function generateCreateActionSpec(options) {
 function generateUpdateActionSpec(options) {
     if (options.actionConfig.omitUpdate)
         return '';
-    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, forAdmin, attributeData } = options;
+    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, attributeData } = options;
     const subjectFunctionName = `update${modelConfig.modelClassName}`;
     const uuidSetup = attributeData.uuidAttributes
         .map(attrName => {
@@ -434,7 +436,7 @@ function generateUpdateActionSpec(options) {
         data,
       })
     }`;
-    const updateContextSpec = singular || forAdmin
+    const updateContextSpec = singular || modelConfig.useDirectModelAccess
         ? ''
         : `
 
@@ -488,7 +490,7 @@ function generateUpdateActionSpec(options) {
 function generateDestroyActionSpec(options) {
     if (options.actionConfig.omitDestroy)
         return '';
-    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, forAdmin } = options;
+    const { path, pathParams, modelConfig, fullyQualifiedModelName, singular } = options;
     const subjectFunctionName = `destroy${modelConfig.modelClassName}`;
     const subjectFunction = singular
         ? `
@@ -499,7 +501,7 @@ function generateDestroyActionSpec(options) {
     const ${subjectFunctionName} = async <StatusCode extends 204 | 400 | 404>(${modelConfig.modelVariableName}: ${modelConfig.modelClassName}, expectedStatus: StatusCode) => {
       return request.delete('/${path}/{id}', expectedStatus, ${formatPathParamsWithId(pathParams, modelConfig.modelVariableName)})
     }`;
-    const destroyContextSpec = singular || forAdmin
+    const destroyContextSpec = singular || modelConfig.useDirectModelAccess
         ? ''
         : `
 

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

@@ -0,0 +1,36 @@
+import { DreamCLI } from '@rvoh/dream/system';
+import { camelize } from '@rvoh/dream/utils';
+import colorize from '../../../cli/helpers/colorize.js';
+export default function printFinalStepsMessage(opts) {
+    const clientFile = `${opts.outputDir}/${camelize(opts.exportName)}.ts`;
+    const importLine = colorize(`+ import { ${opts.exportName} } from '${clientFile}'`, { color: 'green' });
+    DreamCLI.logger.log(`
+Finished generating zustand + openapi-fetch bindings for your application,
+but to wire them into your app, we're going to need your help.
+
+First, you will need to be sure to sync, so that the new openapi
+types are sent over to your client application.
+
+Next, you can use the generated api client in your zustand stores, i.e.
+
+${importLine}
+
+${colorize(`+ import { create } from 'zustand'`, { color: 'green' })}
+
+interface MyState {
+  items: Item[]
+  loading: boolean
+  fetchItems: () => Promise<void>
+}
+
+export const useMyStore = create<MyState>((set) => ({
+  items: [],
+  loading: false,
+  fetchItems: async () => {
+    set({ loading: true })
+    const { data } = await ${opts.exportName}.GET('/items')
+    set({ items: data ?? [], loading: false })
+  },
+}))
+`, { logPrefix: '' });
+}

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

@@ -0,0 +1,55 @@
+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 openapi-typescript will read to produce
+all of its type definitions. 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 typed openapi-fetch client instance that will
+be generated for use in your zustand stores. We recommend naming it something like
+the name of your app, i.e.
+
+  ${defaultVal}
+`);
+        options.exportName = answer || defaultVal;
+    }
+    if (!options.outputDir) {
+        const defaultVal = '../client/src/api';
+        const answer = await cliPrompt(`\
+What would you like the outputDir to be?
+
+The outputDir is the directory where the generated api client and types files
+will be written. If not provided, it will default to:
+
+  ${defaultVal}
+`);
+        options.outputDir = answer || defaultVal;
+    }
+    if (!options.typesFile) {
+        const defaultVal = `${options.outputDir}/${camelize(options.exportName)}.types.d.ts`;
+        const answer = await cliPrompt(`\
+What would you like the typesFile to be?
+
+The typesFile is the path to the generated openapi TypeScript type definitions
+that will be used by the api client. If not provided, it will default to:
+
+  ${defaultVal}
+`);
+        options.typesFile = answer || defaultVal;
+    }
+    return options;
+}

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

@@ -0,0 +1,50 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { camelize } from '@rvoh/dream/utils';
+export default async function writeApiClientFile({ exportName, outputDir, typesFile, }) {
+    const destDir = outputDir;
+    const destPath = path.join(destDir, `${camelize(exportName)}.ts`);
+    try {
+        await fs.access(destPath);
+        return; // early return if the file already exists
+    }
+    catch {
+        // noop
+    }
+    try {
+        await fs.access(destDir);
+    }
+    catch {
+        await fs.mkdir(destDir, { recursive: true });
+    }
+    // compute the relative import path from the output file to the types file
+    const typesRelative = path.relative(destDir, typesFile).replace(/\.d\.ts$/, '.js');
+    const typesImportPath = typesRelative.startsWith('.') ? typesRelative : `./${typesRelative}`;
+    const contents = `\
+import createClient from 'openapi-fetch'
+import type { paths } from '${typesImportPath}'
+
+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'
+}
+
+export const ${exportName} = createClient<paths>({
+  baseUrl: baseUrl(),
+  credentials: 'include',
+
+  // you may customize headers here, for example to add auth tokens:
+  // headers: {
+  //   Authorization: \`Bearer \${getAuthToken()}\`,
+  // },
+})
+`;
+    await fs.writeFile(destPath, 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, typesFile, }) {
+    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) {
+      DreamCLI.logger.logStartProgress(\`[${camelized}] syncing openapi types...\`)
+      await DreamCLI.spawn('npx openapi-typescript ${schemaFile} -o ${typesFile}', {
+        onStdout: message => {
+          DreamCLI.logger.logContinueProgress(\`[${camelized}]\` + ' ' + message, {
+            logPrefixColor: 'green',
+          })
+        },
+      })
+      DreamCLI.logger.logEndProgress()
+    }
+  })
+}\
+`;
+    await fs.writeFile(initializerPath, contents);
+}

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 writeApiClientFile from '../helpers/zustandBindings/writeApiClientFile.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 zustand + openapi-fetch.
+ *
+ * * generates a typed openapi-fetch client file
+ * * generates an initializer, which taps into the sync hooks
+ *   to automatically run openapi-typescript to keep types in sync
+ * * prints a helpful message, instructing devs on the final
+ *   steps for hooking into the newly-generated api mechanisms
+ *   within their client application's zustand stores.
+ */
+export default async function generateOpenapiZustandBindings(options = {}) {
+    const opts = await promptForOptions(options);
+    await writeApiClientFile(opts);
+    await writeInitializer(opts);
+    await DreamCLI.spawn(PackageManager.add(['openapi-fetch', 'openapi-typescript'], { dev: true }));
+    printFinalStepsMessage(opts);
+}

package/dist/cjs/src/generate/resource.js

@@ -17,6 +17,7 @@ export default async function generateResource({ route, fullyQualifiedModelName,
     const resourcefulActions = options.singular ? [...SINGULAR_RESOURCE_ACTIONS] : [...RESOURCE_ACTIONS];
     const onlyActions = options.only?.split(',');
     const forAdmin = /^Admin\//.test(fullyQualifiedControllerName);
+    const forInternal = /^Internal\//.test(fullyQualifiedControllerName);
     await DreamCLI.generateDream({
         fullyQualifiedModelName,
         columnsWithTypes,
@@ -24,7 +25,9 @@ export default async function generateResource({ route, fullyQualifiedModelName,
             serializer: true,
             stiBaseSerializer: options.stiBaseSerializer,
             includeAdminSerializers: forAdmin,
+            includeInternalSerializers: forInternal,
             connectionName: options.connectionName,
+            modelName: options.modelName,
         },
     });
     await generateController({

package/dist/cjs/src/openapi-renderer/SerializerOpenapiRenderer.js

@@ -98,6 +98,7 @@ export default class SerializerOpenapiRenderer {
                 type: 'object',
                 required: sort(uniq(requiredProperties.map(property => this.setCase(property)))),
                 properties: sortObjectByKey(referencedSerializersAndAttributes.attributes),
+                additionalProperties: false,
             },
         };
     }

package/dist/cjs/src/openapi-renderer/body-segment.js

@@ -309,7 +309,11 @@ export default class OpenapiSegmentExpander {
             data.minProperties = objectBodySegment.minProperties;
         }
         let referencedSerializers = [];
-        if (objectBodySegment.additionalProperties) {
+        if (objectBodySegment.additionalProperties === false) {
+            ;
+            data.additionalProperties = false;
+        }
+        else if (objectBodySegment.additionalProperties) {
             const results = this.recursivelyParseBody(objectBodySegment.additionalProperties);
             referencedSerializers = [...referencedSerializers, ...results.referencedSerializers];
             data.additionalProperties = results.openapi;