@rvoh/psychic 2.1.0 → 2.2.1-alpha.1

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

@@ -0,0 +1,341 @@
+import { DreamCLI } from '@rvoh/dream/system';
+import * as cp from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import colorize from '../../cli/helpers/colorize.js';
+/**
+ * Class-based OpenAPI specification diff tool
+ *
+ * Compares current OpenAPI specs against the head branch using oasdiff
+ *
+ * Example usages:
+ *
+ * Instance-based usage
+ *    const diffTool = new OpenApiSpecDiff()
+ *    diffTool.compare(openapiConfigs)
+ *
+ * Factory method usage
+ *    const diffTool = OpenApiSpecDiff.create()
+ *    diffTool.compare(openapiConfigs)
+ *
+ * Static method usage (backward compatibility)
+ *    OpenApiSpecDiff.compare(openapiConfigs)
+ */
+export class OpenApiSpecDiff {
+    /**
+     * The configuration for the oasdiff command
+     */
+    oasdiffConfig;
+    /**
+     * Compares a list of OpenAPI specifications between the current branch and the head branch.
+     *
+     * Uses `oasdiff` under the hood to detect breaking and non-breaking changes for each file,
+     * helping you review and validate API updates with confidence before merging.
+     *
+     * This tool only runs for configurations where `checkDiffs` is enabled.
+     *
+     * @param openapiConfigs - An array of tuples containing the OpenAPI file name and its configuration.
+     * @example
+     * ```ts
+     * const openapiConfigs: [string, PsychicOpenapiConfig][] = [
+     *   ['openapi', { outputFilepath: 'openapi.json' }],
+     * ]
+     * OpenApiSpecDiff.compare(openapiConfigs)
+     * ```
+     */
+    compare(openapiConfigs) {
+        const results = [];
+        this.oasdiffConfig = this.getOasDiffConfig();
+        const comparing = colorize(`🔍 Comparing current OpenAPI Specs against ${this.oasdiffConfig.headBranch}...`, { color: 'cyanBright' });
+        DreamCLI.logger.logStartProgress(comparing, { logPrefixColor: 'cyanBright' });
+        DreamCLI.logger.logContinueProgress(`\n`, { logPrefixColor: 'cyanBright' });
+        for (const [openapiName, config] of openapiConfigs) {
+            const result = this.compareConfig(openapiName, config);
+            results.push(result);
+        }
+        this.processResults(results);
+    }
+    /**
+     * Checks if oasdiff is installed locally
+     */
+    hasOasDiffInstalled() {
+        try {
+            cp.execSync('oasdiff --version', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Fetch the head branch of a remote using git remote show origin
+     * default to main if not set
+     */
+    getHeadBranch() {
+        let head = '';
+        const output = cp.execSync('git remote show origin', { encoding: 'utf-8' });
+        const lines = output.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('HEAD branch:')) {
+                head = trimmed.replace('HEAD branch:', '').trim() || 'main';
+            }
+        }
+        return head;
+    }
+    /**
+     * Validates that oasdiff is installed and builds the oasdiff config
+     */
+    getOasDiffConfig() {
+        const headBranch = this.getHeadBranch();
+        if (this.hasOasDiffInstalled()) {
+            DreamCLI.logger.logContinueProgress('🎉 oasdiff package found\n');
+            return {
+                command: 'oasdiff',
+                baseArgs: [],
+                headBranch,
+            };
+        }
+        throw new Error(`⚠️ oasdiff not found.
+    
+      Install it via the instructions here:
+        https://github.com/tufin/oasdiff
+      `);
+    }
+    /**
+     * Runs oasdiff command and returns the output
+     */
+    runOasDiffCommand(subcommand, mainPath, currentPath, flags) {
+        if (!this.oasdiffConfig) {
+            throw new Error('OasDiff config not initialized');
+        }
+        const args = [...this.oasdiffConfig.baseArgs, subcommand, mainPath, currentPath];
+        if (flags && flags.length > 0) {
+            args.push(...flags.map(flag => `--${flag}`));
+        }
+        try {
+            const output = cp.execFileSync(this.oasdiffConfig.command, args, {
+                shell: true,
+                encoding: 'utf8',
+                cwd: process.cwd(),
+                stdio: 'pipe',
+            });
+            return output.trim();
+        }
+        catch (error) {
+            const errorOutput = error instanceof Error ? error.message : String(error);
+            return errorOutput;
+        }
+    }
+    /**
+     * Compares two OpenAPI files using oasdiff
+     */
+    compareSpecs(mainFilePath, currentFilePath) {
+        if (!this.oasdiffConfig) {
+            throw new Error('OasDiff config not initialized');
+        }
+        const breakingChanges = this.runOasDiffCommand('breaking', mainFilePath, currentFilePath);
+        const changelogChanges = this.runOasDiffCommand('changelog', mainFilePath, currentFilePath);
+        const breaking = breakingChanges && !breakingChanges.includes('Command failed')
+            ? breakingChanges.split('\n').filter(line => line.trim())
+            : [];
+        const changelog = changelogChanges && !changelogChanges.includes('Command failed')
+            ? changelogChanges.split('\n').filter(line => line.trim())
+            : [];
+        const failedToCompare = breakingChanges.includes('Command failed')
+            ? breakingChanges
+            : changelogChanges.includes('Command failed')
+                ? changelogChanges
+                : '';
+        return {
+            breaking,
+            changelog,
+            error: failedToCompare,
+        };
+    }
+    /**
+     * Creates a temporary file path for the head branch content
+     */
+    createTempFilePath(filePath) {
+        const tempFileName = `temp_main_${path.basename(filePath)}`;
+        return path.join(path.dirname(filePath), tempFileName);
+    }
+    /**
+     * Retrieves head branch content for a file
+     */
+    getHeadBranchContent(filePath) {
+        if (!this.oasdiffConfig) {
+            throw new Error('OasDiff config not initialized');
+        }
+        const branchRef = process.env.CI === '1' ? `origin/${this.oasdiffConfig.headBranch}` : this.oasdiffConfig.headBranch;
+        return cp.execSync(`git show ${branchRef}:${filePath}`, {
+            encoding: 'utf8',
+            cwd: process.cwd(),
+        });
+    }
+    /**
+     * Compares a single OpenAPI file against head branch
+     */
+    compareConfig(openapiName, config) {
+        const result = {
+            file: openapiName,
+            hasChanges: false,
+            breaking: [],
+            changelog: [],
+        };
+        const currentFilePath = config.outputFilepath;
+        if (!fs.existsSync(currentFilePath)) {
+            result.error = `File ${config.outputFilepath} does not exist in current branch`;
+            return result;
+        }
+        const tempMainFilePath = this.createTempFilePath(config.outputFilepath);
+        const mainContent = this.getHeadBranchContent(config.outputFilepath);
+        fs.mkdirSync(path.dirname(tempMainFilePath), { recursive: true });
+        fs.writeFileSync(tempMainFilePath, mainContent);
+        try {
+            const { breaking, changelog, error } = this.compareSpecs(tempMainFilePath, currentFilePath);
+            result.breaking = breaking;
+            result.changelog = changelog;
+            result.hasChanges = breaking.length > 0 || changelog.length > 0;
+            result.error = error ?? '';
+        }
+        catch (error) {
+            result.error = `Could not retrieve ${config.outputFilepath} from ${this.oasdiffConfig?.headBranch} branch: ${String(error)}`;
+        }
+        finally {
+            if (fs.existsSync(tempMainFilePath)) {
+                fs.unlinkSync(tempMainFilePath);
+            }
+        }
+        return result;
+    }
+    /**
+     * Process and display the comparison results
+     */
+    processResults(results) {
+        let hasAnyChanges = false;
+        let hasBreakingChanges = false;
+        for (const result of results) {
+            if (result.error) {
+                this.logError(result);
+            }
+            else if (result.hasChanges) {
+                this.logChanges(result);
+                hasAnyChanges = true;
+                if (result.breaking.length > 0) {
+                    this.logBreakingChanges(result);
+                    hasBreakingChanges = true;
+                }
+                if (result.changelog.length > 0) {
+                    this.logChangelog(result);
+                }
+            }
+            else {
+                this.logNoChanges(result);
+            }
+        }
+        this.logSummary(hasAnyChanges, hasBreakingChanges);
+    }
+    /**
+     * Log error for a comparison result
+     */
+    logError(result) {
+        const file = colorize(`❌ ${result.file}`, { color: 'whiteBright' });
+        const error = colorize(`${result.error}`, { color: 'redBright' });
+        DreamCLI.logger.logContinueProgress(`${file}: ${error}`, { logPrefixColor: 'redBright' });
+    }
+    /**
+     * Log changes for a comparison result
+     */
+    logChanges(result) {
+        const file = colorize(`${result.file}`, { color: 'whiteBright' });
+        const changes = colorize('HAS CHANGES', { color: 'yellowBright' });
+        DreamCLI.logger.logContinueProgress(`${file}: ${changes}`, { logPrefixColor: 'yellowBright' });
+    }
+    /**
+     * Log breaking changes for a comparison result
+     */
+    logBreakingChanges(result) {
+        DreamCLI.logger.logContinueProgress(`   ${colorize(`🚨 BREAKING CHANGES:`, { color: 'redBright' })}`, {
+            logPrefixColor: 'redBright',
+        });
+        result.breaking.forEach(change => {
+            DreamCLI.logger.logContinueProgress(`      ${colorize(`• ${change}`, { color: 'redBright' })}`, {
+                logPrefixColor: 'redBright',
+            });
+        });
+    }
+    /**
+     * Log changelog for a comparison result
+     */
+    logChangelog(result) {
+        DreamCLI.logger.logContinueProgress(`   ${colorize(`📋 CHANGELOG:`, { color: 'blueBright' })}`, {
+            logPrefixColor: 'blueBright',
+        });
+        const changelogLines = result.changelog;
+        changelogLines.forEach(line => {
+            DreamCLI.logger.logContinueProgress(`      ${colorize(line, { color: 'whiteBright' })}`, {
+                logPrefixBgColor: 'bgWhite',
+                logPrefixColor: 'white',
+            });
+        });
+    }
+    /**
+     * Log no changes for a comparison result
+     */
+    logNoChanges(result) {
+        const file = colorize(`${result.file}`, { color: 'whiteBright' });
+        const changes = colorize('No changes', { color: 'greenBright' });
+        DreamCLI.logger.logContinueProgress(`${file}: ${changes}`, { logPrefixColor: 'greenBright' });
+    }
+    /**
+     * Log final summary and handle exit conditions
+     */
+    logSummary(hasAnyChanges, hasBreakingChanges) {
+        DreamCLI.logger.logContinueProgress(`\n${colorize(`${'='.repeat(60)}`, { color: 'gray' })}`, {
+            logPrefixColor: 'gray',
+        });
+        if (hasBreakingChanges) {
+            DreamCLI.logger.logContinueProgress(`${colorize(`🚨 CRITICAL:`, { color: 'redBright' })} ${colorize(`Breaking changes detected in current branch compared to ${this.oasdiffConfig?.headBranch}! Review before merging.`, { color: 'whiteBright' })}`, { logPrefixColor: 'redBright' });
+            DreamCLI.logger.logContinueProgress(`${colorize(`${'='.repeat(60)}`, { color: 'gray' })}`, {
+                logPrefixColor: 'gray',
+            });
+            DreamCLI.logger.logContinueProgress('\n'.repeat(5), {
+                logPrefixColor: 'gray',
+            });
+            throw new BreakingChangesDetectedInOpenApiSpecError(this.oasdiffConfig);
+        }
+        else if (hasAnyChanges) {
+            const summary = colorize(`📊 Summary: Some OpenAPI files have non-breaking changes in current branch compared to ${this.oasdiffConfig?.headBranch}`, { color: 'yellow' });
+            DreamCLI.logger.logContinueProgress(summary, { logPrefixColor: 'yellow' });
+        }
+        else {
+            const summary = colorize(`📊 Summary: All OpenAPI files in current branch are identical to ${this.oasdiffConfig?.headBranch} branch`, { color: 'green' });
+            DreamCLI.logger.logContinueProgress(summary, { logPrefixColor: 'green' });
+        }
+    }
+    /**
+     * Static factory method for convenience
+     */
+    static create() {
+        return new OpenApiSpecDiff();
+    }
+    /**
+     * Static method to maintain compatibility with functional approach
+     */
+    static compare(openapiConfigs) {
+        const instance = OpenApiSpecDiff.create();
+        instance.compare(openapiConfigs);
+    }
+}
+export class BreakingChangesDetectedInOpenApiSpecError extends Error {
+    oasdiffConfig;
+    constructor(oasdiffConfig) {
+        super();
+        this.oasdiffConfig = oasdiffConfig;
+        this.name = 'BreakingChangesDetectedInOpenApiSpecError';
+    }
+    get message() {
+        return `Breaking changes detected in current branch compared to ${this.oasdiffConfig.headBranch}! Review before merging.`;
+    }
+}

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

@@ -9,7 +9,9 @@ import OpenapiAppRenderer from '../openapi-renderer/app.js';
 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 printRoutes from './helpers/printRoutes.js';
+export { BreakingChangesDetectedInOpenApiSpecError } from './helpers/OpenApiSpecDiff.js';
 export default class PsychicBin {
     static async generateController(controllerName, actions) {
         await generateController({
@@ -59,6 +61,11 @@ export default class PsychicBin {
             await new ASTPsychicTypesBuilder().build();
         });
     }
+    static openapiDiff() {
+        const psychicApp = PsychicApp.getOrFail();
+        const openapiConfigsWithCheckDiffs = Object.entries(psychicApp.openapi).filter(([, config]) => config.checkDiffs);
+        OpenApiSpecDiff.compare(openapiConfigsWithCheckDiffs);
+    }
     static async syncOpenapiTypescriptFiles() {
         DreamCLI.logger.logStartProgress(`syncing openapi types...`);
         // https://rvohealth.atlassian.net/browse/PDTC-8359

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

@@ -1,5 +1,5 @@
 import { DreamCLI } from '@rvoh/dream/system';
-import PsychicBin from '../bin/index.js';
+import PsychicBin, { BreakingChangesDetectedInOpenApiSpecError } from '../bin/index.js';
 import generateController from '../generate/controller.js';
 import generateSyncEnumsInitializer from '../generate/initializer/syncEnums.js';
 import generateSyncOpenapiTypescriptInitializer from '../generate/initializer/syncOpenapiTypescript.js';
@@ -14,6 +14,10 @@ ${INDENT}all properties default to not nullable; null can be allowed by appendin
 ${INDENT}    subtitle:string:optional
 ${INDENT}
 ${INDENT}supported types:
+${INDENT}    - uuid:
+${INDENT}    - uuid[]:
+${INDENT}        a column optimized for storing UUIDs
+${INDENT}
 ${INDENT}    - citext:
 ${INDENT}    - citext[]:
 ${INDENT}        case insensitive text (indexes and queries are automatically case insensitive)
@@ -196,6 +200,27 @@ export default class PsychicCLI {
             await PsychicBin.syncOpenapiJson();
             process.exit();
         });
+        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')
+            .action(async (options) => {
+            await initializePsychicApp();
+            try {
+                PsychicBin.openapiDiff();
+            }
+            catch (error) {
+                if (error instanceof BreakingChangesDetectedInOpenApiSpecError) {
+                    if (options.failOnBreaking) {
+                        console.error(error.message);
+                        process.exit(1);
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
     }
     /**
      * @internal

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

@@ -131,7 +131,7 @@ export default class PsychicController {
     /**
      * @internal
      *
-     * Used for displaying routes when running `yarn psy routes`
+     * Used for displaying routes when running `pnpm psy routes`
      * cli command
      */
     static get disaplayName() {

package/dist/cjs/src/devtools/helpers/launchDevServer.js

@@ -6,7 +6,7 @@ import UnexpectedUndefined from '../../error/UnexpectedUndefined.js';
 import PsychicApp from '../../psychic-app/index.js';
 const devServerProcesses = {};
 const debugEnabled = debuglog('psychic').enabled;
-export async function launchDevServer(key, { port = 3000, cmd = 'yarn client', timeout = 5000 } = {}) {
+export async function launchDevServer(key, { port = 3000, cmd = 'pnpm client', timeout = 5000 } = {}) {
     if (devServerProcesses[key])
         return;
     if (debugEnabled)

package/dist/cjs/src/error/psychic-app/init-missing-package-manager.js

@@ -10,7 +10,7 @@ within conf/app.ts, you must have a call to "#set('packageManager', '<YOUR_CHOSE
 
   // conf/app.ts
   export default async (psy: PsychicApp) => {
-    psy.set('packageManager', 'yarn')
+    psy.set('packageManager', 'pnpm')
   }
     `;
     }

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

@@ -7,7 +7,7 @@ export default function generateResourceControllerSpecContent(options) {
     const modelConfig = createModelConfiguration(options);
     const actionConfig = createActionConfiguration(options);
     const attributeData = processAttributes(options.columnsWithTypes, modelConfig, options.fullyQualifiedModelName);
-    const imports = generateImportStatements(modelConfig, attributeData.dreamImports, options.owningModel);
+    const imports = generateImportStatements(modelConfig, attributeData.dreamImports, options.owningModel, attributeData.uuidAttributeIncluded);
     return generateSpecTemplate({
         ...options,
         path,
@@ -62,6 +62,8 @@ function processAttributes(columnsWithTypes, modelConfig, fullyQualifiedModelNam
         originalValueVariableAssignments: [],
         dateAttributeIncluded: false,
         datetimeAttributeIncluded: false,
+        uuidAttributeIncluded: false,
+        uuidArrayAttributes: [],
         dreamImports: [],
     };
     for (const attribute of columnsWithTypes) {
@@ -87,8 +89,9 @@ function parseAttribute(attribute) {
     const [rawAttributeName, rawAttributeType, , enumValues] = attribute.split(':');
     if (!rawAttributeName || !rawAttributeType)
         return null;
+    const sanitizedAttrType = camelize(rawAttributeType)?.toLowerCase();
     // Handle belongs_to relationships
-    if (rawAttributeType === 'belongs_to') {
+    if (sanitizedAttrType === 'belongsto') {
         // For belongs_to relationships, convert "Ticketing/Ticket" to "ticket"
         const attributeName = camelize(rawAttributeName.split('/').pop());
         return { attributeName, attributeType: 'belongs_to', isArray: false, enumValues };
@@ -101,12 +104,14 @@ function parseAttribute(attribute) {
         return null;
     const arrayBracketRegexp = /\[\]$/;
     const isArray = arrayBracketRegexp.test(rawAttributeType);
-    const attributeType = rawAttributeType.replace(arrayBracketRegexp, '');
+    const _attributeType = rawAttributeType.replace(arrayBracketRegexp, '');
+    const attributeType = /uuid$/.test(rawAttributeName) ? 'uuid' : _attributeType;
     return { attributeName, attributeType, isArray, enumValues };
 }
 function processAttributeByType({ attributeType, attributeName, isArray, enumValues, dotNotationVariable, fullyQualifiedModelName, attributeData, }) {
-    switch (attributeType) {
-        case 'belongs_to':
+    const sanitizedAttributeType = camelize(attributeType).toLowerCase();
+    switch (sanitizedAttributeType) {
+        case 'belongsto':
             // belongs_to relationships are NOT included in comparable attributes or create/update data
             // They are only tracked for original values in update contexts
             break;
@@ -135,6 +140,9 @@ function processAttributeByType({ attributeType, attributeName, isArray, enumVal
         case 'datetime':
             processDateTimeAttribute({ attributeName, isArray, dotNotationVariable, attributeData });
             break;
+        case 'uuid':
+            processUuidAttribute({ attributeName, isArray, dotNotationVariable, attributeData });
+            break;
     }
 }
 function processEnumAttribute({ attributeName, isArray, enumValues, dotNotationVariable, attributeData, }) {
@@ -190,6 +198,21 @@ function processDateTimeAttribute({ attributeName, isArray, dotNotationVariable,
     attributeData.expectEqualOriginalValue.push(`expect(${dotNotationVariable}${isArray ? '[0]' : ''}).toEqualDateTime(now)`);
     attributeData.expectEqualUpdatedValue.push(`expect(${dotNotationVariable}${isArray ? '[0]' : ''}).toEqualDateTime(lastHour)`);
 }
+function processUuidAttribute({ attributeName, isArray, dotNotationVariable, attributeData, }) {
+    attributeData.uuidAttributeIncluded = true;
+    if (isArray) {
+        attributeData.uuidArrayAttributes.push(attributeName);
+    }
+    const newUuidVariableName = `new${capitalize(attributeName)}`;
+    // For arrays, the variable itself is an array, so we use it directly without brackets
+    const uuidValue = attributeName;
+    const newUuidValue = newUuidVariableName;
+    attributeData.attributeCreationKeyValues.push(`${attributeName}: ${uuidValue},`);
+    attributeData.attributeUpdateKeyValues.push(`${attributeName}: ${newUuidValue},`);
+    attributeData.comparableOriginalAttributeKeyValues.push(`${attributeName}: ${dotNotationVariable},`);
+    attributeData.expectEqualOriginalValue.push(`expect(${dotNotationVariable}).toEqual(${attributeName})`);
+    attributeData.expectEqualUpdatedValue.push(`expect(${dotNotationVariable}).toEqual(${newUuidVariableName})`);
+}
 function addOriginalValueTracking(attributeType, attributeName, isArray, dotNotationVariable, attributeData) {
     const hardToCompareArray = (attributeType === 'date' || attributeType === 'datetime') && isArray;
     // Exclude belongs_to relationships from original value tracking
@@ -199,7 +222,7 @@ function addOriginalValueTracking(attributeType, attributeName, isArray, dotNota
         attributeData.expectEqualOriginalNamedVariable.push(`expect(${dotNotationVariable}).toEqual(${originalAttributeVariableName})`);
     }
 }
-function generateImportStatements(modelConfig, dreamImports, owningModel) {
+function generateImportStatements(modelConfig, dreamImports, owningModel, uuidAttributeIncluded) {
     const importStatements = compact([
         importStatementForModel(modelConfig.fullyQualifiedModelName),
         importStatementForModel(modelConfig.userModelName),
@@ -208,10 +231,11 @@ function generateImportStatements(modelConfig, dreamImports, owningModel) {
         importStatementForModelFactory(modelConfig.userModelName),
         owningModel ? importStatementForModelFactory(owningModel) : undefined,
     ]);
+    const cryptoImportLine = uuidAttributeIncluded ? `import { randomUUID } from 'node:crypto'\n` : '';
     const dreamImportLine = dreamImports.length
         ? `import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'\n`
         : '';
-    return `${dreamImportLine}${uniq(importStatements).join('\n')}
+    return `${cryptoImportLine}${dreamImportLine}${uniq(importStatements).join('\n')}
 import { RequestBody, session, SpecRequestType } from '@spec/unit/helpers/${addImportSuffix('authentication.js')}'`;
 }
 function generateSpecTemplate(options) {
@@ -312,13 +336,28 @@ function generateCreateActionSpec(options) {
         return '';
     const { path, pathParams, modelConfig, fullyQualifiedModelName, forAdmin, singular, attributeData } = options;
     const subjectFunctionName = `create${modelConfig.modelClassName}`;
-    const dateTimeSetup = `${attributeData.dateAttributeIncluded
+    const uuidAttributeNames = attributeData.attributeCreationKeyValues
+        .map(kv => {
+        const match = kv.match(/^(\w+):\s*\1,?$/);
+        return match?.[1];
+    })
+        .filter((name) => Boolean(name));
+    const uuidSetup = uuidAttributeNames
+        .map(attrName => {
+        const isArray = attributeData.uuidArrayAttributes.includes(attrName);
+        return isArray ? `const ${attrName} = [randomUUID()]` : `const ${attrName} = randomUUID()`;
+    })
+        .join('\n      ');
+    const dateTimeSetup = `${uuidSetup
+        ? `
+      ${uuidSetup}`
+        : ''}${attributeData.dateAttributeIncluded
         ? `
       const today = CalendarDate.today()`
         : ''}${attributeData.datetimeAttributeIncluded
         ? `
       const now = DateTime.now()`
-        : ''}${attributeData.dateAttributeIncluded || attributeData.datetimeAttributeIncluded ? '\n' : ''}`;
+        : ''}${uuidSetup || attributeData.dateAttributeIncluded || attributeData.datetimeAttributeIncluded ? '\n' : ''}`;
     const modelQuery = forAdmin
         ? `${modelConfig.modelClassName}.firstOrFail()`
         : `${modelConfig.owningModelVariableName}.associationQuery('${singular ? modelConfig.modelVariableName : pluralize(modelConfig.modelVariableName)}').firstOrFail()`;
@@ -354,7 +393,28 @@ function generateUpdateActionSpec(options) {
         return '';
     const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, forAdmin, attributeData } = options;
     const subjectFunctionName = `update${modelConfig.modelClassName}`;
-    const dateTimeSetup = `${attributeData.dateAttributeIncluded
+    const uuidAttributeNames = attributeData.attributeUpdateKeyValues
+        .filter(kv => {
+        const match = kv.match(/^(\w+):\s*new([A-Z]\w+),?$/);
+        return match && match[1] && camelize(match[1]) === camelize(match[2]);
+    })
+        .map(kv => {
+        const match = kv.match(/^(\w+):/);
+        return match?.[1];
+    })
+        .filter(Boolean);
+    const uuidSetup = uuidAttributeNames
+        .map(attrName => {
+        const isArray = attributeData.uuidArrayAttributes.includes(attrName);
+        return isArray
+            ? `const new${capitalize(attrName)} = [randomUUID()]`
+            : `const new${capitalize(attrName)} = randomUUID()`;
+    })
+        .join('\n      ');
+    const dateTimeSetup = `${uuidSetup
+        ? `
+      ${uuidSetup}`
+        : ''}${attributeData.dateAttributeIncluded
         ? `
       const yesterday = CalendarDate.yesterday()`
         : ''}${attributeData.datetimeAttributeIncluded
@@ -398,7 +458,21 @@ function generateUpdateActionSpec(options) {
         ${attributeData.originalValueVariableAssignments.length ? attributeData.originalValueVariableAssignments.join('\n        ') : ''}
 
         await ${subjectFunctionName}(${modelConfig.modelVariableName}, {
-          ${attributeData.attributeUpdateKeyValues.length ? attributeData.attributeUpdateKeyValues.join('\n          ') : ''}
+          ${attributeData.attributeUpdateKeyValues.length
+            ? attributeData.attributeUpdateKeyValues
+                .map(kv => {
+                const match = kv.match(/^(\w+):\s*new([A-Z]\w+),?$/);
+                if (match && match[1]) {
+                    const attrName = match[1];
+                    const isArray = attributeData.uuidArrayAttributes.includes(attrName);
+                    return isArray
+                        ? kv.replace(/\bnew[A-Z]\w+\b/g, '[randomUUID()]')
+                        : kv.replace(/\bnew[A-Z]\w+\b/g, 'randomUUID()');
+                }
+                return kv;
+            })
+                .join('\n          ')
+            : ''}
         }, 404)
 
         await ${modelConfig.modelVariableName}.reload()

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

@@ -8,7 +8,7 @@ export default async function installOpenapiTypescript() {
     try {
         await DreamCLI.spawn(cmd);
     }
-    catch (err) {
+    catch {
         console.log(`Failed to install openapi-typescript as a dev dependency. Please make sure the following command succeeds:
 
 "${cmd}"

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

@@ -298,6 +298,7 @@ function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDesce
         if (associatedClass === undefined) {
             let serializerCheck;
             try {
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
                 ;
                 DataTypeForOpenapi?.prototype?.serializers;
             }

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

@@ -57,7 +57,7 @@ export default class OpenapiAppRenderer {
             openapi: '3.1.0',
             info: {
                 version: openapiConfig?.info?.version || 'unknown version',
-                title: openapiConfig?.info?.title || 'unknown title',
+                title: openapiConfig?.info?.title || `${psychicApp.appName} | ${openapiName}`,
                 description: openapiConfig?.info?.description || 'The autogenerated openapi spec for your app',
             },
             paths: {},