@rvoh/psychic 0.37.9 → 0.37.10

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

@@ -9,6 +9,40 @@ const syncEnums_js_1 = __importDefault(require("../generate/initializer/syncEnum
 const syncOpenapiTypescript_js_1 = __importDefault(require("../generate/initializer/syncOpenapiTypescript.js"));
 const reduxBindings_js_1 = __importDefault(require("../generate/openapi/reduxBindings.js"));
 const Watcher_js_1 = __importDefault(require("../watcher/Watcher.js"));
+const INDENT = '                  ';
+const columnsWithTypesDescription = `space separated snake-case (except for belongs_to model name) properties like this:
+${INDENT}    title:citext subtitle:string body_markdown:text style:enum:post_styles:formal,informal User:belongs_to
+${INDENT}
+${INDENT}all properties default to not nullable; null can be allowed by appending ':optional':
+${INDENT}    subtitle:string:optional
+${INDENT}
+${INDENT}supported types:
+${INDENT}    - citext:
+${INDENT}        case insensitive text (indexes and queries are automatically case insensitive)
+${INDENT}
+${INDENT}    - string:
+${INDENT}        varchar; allowed length defaults to 255, but may be customized, e.g.: subtitle:string:128 or subtitle:string:128:optional
+${INDENT}
+${INDENT}    - text
+${INDENT}
+${INDENT}    - integer
+${INDENT}
+${INDENT}    - decimal:
+${INDENT}        scale,precision is required, e.g.: volume:decimal:3,2 or volume:decimal:3,2:optional
+${INDENT}
+${INDENT}    - enum:
+${INDENT}        include the enum name to automatically create the enum:
+${INDENT}          type:enum:room_types:bathroom,kitchen,bedroom or type:enum:room_types:bathroom,kitchen,bedroom:optional
+${INDENT}
+${INDENT}        omit the enum values to leverage an existing enum (omits the enum type creation):
+${INDENT}          type:enum:room_types or type:enum:room_types:optional
+${INDENT}
+${INDENT}    - belongs_to:
+${INDENT}        Not only updates the migration but also adds a BelongsTo association to the generated model:
+${INDENT}          Place:belongs_to
+${INDENT}        
+${INDENT}        Include the full Path to the model. E.g., if the Coach model is in src/app/models/Health/Coach:
+${INDENT}          Health/Coach:belongs_to`;
 class PsychicCLI {
     static provide(program, { initializePsychicApp, seedDb, }) {
         dream_1.DreamCLI.generateDreamCli(program, {
@@ -23,10 +57,10 @@ class PsychicCLI {
             .alias('g:resource')
             .description('create a Dream model, migration, controller, serializer, and spec placeholders')
             .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") (simply to save time making changes to the generated code). Defaults to User')
+            .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") (simply to save time making changes to the generated code). Defaults to User')
             .argument('<path>', 'URL path from root domain')
             .argument('<modelName>', 'the name of the model to create, e.g. Post or Settings/CommunicationPreferences')
-            .argument('[columnsWithTypes...]', 'properties of the model property1:text/string/enum/etc. property2:text/string/enum/etc. ... propertyN:text/string/enum/etc.')
+            .argument('[columnsWithTypes...]', columnsWithTypesDescription)
             .action(async (route, modelName, columnsWithTypes, options) => {
             await initializePsychicApp();
             await index_js_1.default.generateResource(route, modelName, columnsWithTypes, options);

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

@@ -31,7 +31,6 @@ const dream_1 = require("@rvoh/dream");
 const node_fs_1 = require("node:fs");
 const fs = __importStar(require("node:fs/promises"));
 const UnexpectedUndefined_js_1 = __importDefault(require("../error/UnexpectedUndefined.js"));
-const EnvInternal_js_1 = __importDefault(require("../helpers/EnvInternal.js"));
 const psychicFileAndDirPaths_js_1 = __importDefault(require("../helpers/path/psychicFileAndDirPaths.js"));
 const psychicPath_js_1 = __importDefault(require("../helpers/path/psychicPath.js"));
 const generateControllerContent_js_1 = __importDefault(require("./helpers/generateControllerContent.js"));
@@ -44,12 +43,12 @@ async function generateController({ fullyQualifiedControllerName, fullyQualified
     fullyQualifiedControllerName = (0, dream_1.standardizeFullyQualifiedModelName)(`${fullyQualifiedControllerName.replace(/Controller$/, '')}Controller`);
     const route = (0, dream_1.hyphenize)(fullyQualifiedControllerName.replace(/Controller$/, ''));
     const allControllerNameParts = fullyQualifiedControllerName.split('/');
-    const isAdmin = allControllerNameParts[0] === 'Admin';
-    const controllerNameParts = isAdmin ? [allControllerNameParts.shift()] : [];
+    const forAdmin = allControllerNameParts[0] === 'Admin';
+    const controllerNameParts = forAdmin ? [allControllerNameParts.shift()] : [];
     for (let index = 0; index < allControllerNameParts.length; index++) {
-        if (controllerNameParts.length > (isAdmin ? 1 : 0)) {
+        if (controllerNameParts.length > (forAdmin ? 1 : 0)) {
             // Write the ancestor controller
-            const [baseAncestorName, baseAncestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, isAdmin, { forBaseController: true });
+            const [baseAncestorName, baseAncestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, forAdmin, { forBaseController: true });
             if (baseAncestorName === undefined)
                 throw new UnexpectedUndefined_js_1.default();
             if (baseAncestorImportStatement === undefined)
@@ -63,6 +62,7 @@ async function generateController({ fullyQualifiedControllerName, fullyQualified
                     ancestorName: baseAncestorName,
                     fullyQualifiedControllerName: baseControllerName,
                     omitOpenApi: true,
+                    forAdmin,
                 }));
             }
         }
@@ -71,7 +71,7 @@ async function generateController({ fullyQualifiedControllerName, fullyQualified
             controllerNameParts.push(namedPart);
     }
     // Write the controller
-    const [ancestorName, ancestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, isAdmin, {
+    const [ancestorName, ancestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, forAdmin, {
         forBaseController: false,
     });
     if (ancestorName === undefined)
@@ -81,8 +81,7 @@ async function generateController({ fullyQualifiedControllerName, fullyQualified
     const { relFilePath, absDirPath, absFilePath } = (0, psychicFileAndDirPaths_js_1.default)((0, psychicPath_js_1.default)('controllers'), fullyQualifiedControllerName + `.ts`);
     await fs.mkdir(absDirPath, { recursive: true });
     try {
-        if (!EnvInternal_js_1.default.isTest)
-            console.log(`generating controller: ${relFilePath}`);
+        console.log(`generating controller: ${relFilePath}`);
         await fs.writeFile(absFilePath, (0, generateControllerContent_js_1.default)({
             ancestorImportStatement,
             ancestorName,
@@ -90,6 +89,7 @@ async function generateController({ fullyQualifiedControllerName, fullyQualified
             fullyQualifiedModelName,
             actions,
             owningModel,
+            forAdmin,
         }));
     }
     catch (error) {
@@ -108,22 +108,22 @@ async function generateController({ fullyQualifiedControllerName, fullyQualified
         columnsWithTypes,
         resourceSpecs,
         owningModel,
+        forAdmin,
     });
 }
-function baseAncestorNameAndImport(controllerNameParts, isAdmin, { forBaseController }) {
+function baseAncestorNameAndImport(controllerNameParts, forAdmin, { forBaseController }) {
     const maybeAncestorNameForBase = `${controllerNameParts.slice(0, controllerNameParts.length - 1).join('')}BaseController`;
     const dotFiles = forBaseController ? '..' : '.';
-    return controllerNameParts.length === (isAdmin ? 2 : 1)
-        ? isAdmin
+    return controllerNameParts.length === (forAdmin ? 2 : 1)
+        ? forAdmin
             ? [`AdminAuthedController`, `import AdminAuthedController from '${dotFiles}/AuthedController.js'`]
             : [`AuthedController`, `import AuthedController from '${dotFiles}/AuthedController.js'`]
         : [maybeAncestorNameForBase, `import ${maybeAncestorNameForBase} from '${dotFiles}/BaseController.js'`];
 }
-async function generateControllerSpec({ fullyQualifiedControllerName, route, fullyQualifiedModelName, columnsWithTypes, resourceSpecs, owningModel, }) {
+async function generateControllerSpec({ fullyQualifiedControllerName, route, fullyQualifiedModelName, columnsWithTypes, resourceSpecs, owningModel, forAdmin, }) {
     const { relFilePath, absDirPath, absFilePath } = (0, psychicFileAndDirPaths_js_1.default)((0, psychicPath_js_1.default)('controllerSpecs'), fullyQualifiedControllerName + `.spec.ts`);
     try {
-        if (!EnvInternal_js_1.default.isTest)
-            console.log(`generating controller: ${relFilePath}`);
+        console.log(`generating controller spec: ${relFilePath}`);
         await fs.mkdir(absDirPath, { recursive: true });
         await fs.writeFile(absFilePath, resourceSpecs && fullyQualifiedModelName
             ? (0, generateResourceControllerSpecContent_js_1.default)({
@@ -132,6 +132,7 @@ async function generateControllerSpec({ fullyQualifiedControllerName, route, ful
                 fullyQualifiedModelName,
                 columnsWithTypes,
                 owningModel,
+                forAdmin,
             })
             : (0, generateControllerSpecContent_js_1.default)(fullyQualifiedControllerName));
     }

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

@@ -7,7 +7,7 @@ exports.default = generateControllerContent;
 const dream_1 = require("@rvoh/dream");
 const pluralize_esm_1 = __importDefault(require("pluralize-esm"));
 const relativePsychicPath_js_1 = __importDefault(require("../../helpers/path/relativePsychicPath.js"));
-function generateControllerContent({ ancestorName, ancestorImportStatement, fullyQualifiedControllerName, fullyQualifiedModelName, actions = [], omitOpenApi = false, owningModel, }) {
+function generateControllerContent({ ancestorName, ancestorImportStatement, fullyQualifiedControllerName, fullyQualifiedModelName, actions = [], omitOpenApi = false, owningModel, forAdmin, }) {
     fullyQualifiedControllerName = (0, dream_1.standardizeFullyQualifiedModelName)(fullyQualifiedControllerName);
     const additionalImports = [];
     const controllerClassName = (0, dream_1.globalClassNameFromFullyQualifiedModelName)(fullyQualifiedControllerName);
@@ -25,6 +25,13 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
         pluralizedModelAttributeName = (0, pluralize_esm_1.default)(modelAttributeName);
         additionalImports.push(importStatementForModel(fullyQualifiedControllerName, fullyQualifiedModelName));
     }
+    const defaultOpenapiSerializerKeyProperty = forAdmin
+        ? `
+    serializerKey: 'admin',`
+        : '';
+    const loadQueryBase = forAdmin
+        ? (modelClassName ?? 'no-class-name')
+        : `this.${owningModelProperty}.associationQuery('${pluralizedModelAttributeName}')`;
     const methodDefs = actions.map(methodName => {
         switch (methodName) {
             case 'create':
@@ -33,11 +40,12 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
   @OpenAPI(${modelClassName}, {
     status: 201,
     tags: openApiTags,
-    description: 'Create ${aOrAnDreamModelName(modelClassName)}',
+    description: 'Create ${aOrAnDreamModelName(modelClassName)}',${defaultOpenapiSerializerKeyProperty}
   })
   public async create() {
-    //    const ${modelAttributeName} = await this.${owningModelProperty}.createAssociation('${pluralizedModelAttributeName}', this.paramsFor(${modelClassName}))
-    //    this.created(${modelAttributeName})
+    // let ${modelAttributeName} = await ${forAdmin ? `${modelClassName}.create(` : `this.${owningModelProperty}.createAssociation('${pluralizedModelAttributeName}', `}this.paramsFor(${modelClassName}))
+    // if (${modelAttributeName}.isPersisted) ${modelAttributeName} = await ${modelAttributeName}.loadFor('${forAdmin ? 'admin' : 'default'}').execute()
+    // this.created(${modelAttributeName})
   }`;
                 else
                     return `\
@@ -56,11 +64,13 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
     tags: openApiTags,
     description: 'Fetch multiple ${(0, pluralize_esm_1.default)(modelClassName)}',
     many: true,
-    serializerKey: 'summary',
+    serializerKey: '${forAdmin ? 'adminSummary' : 'summary'}',
   })
   public async index() {
-    //    const ${pluralizedModelAttributeName} = await this.${owningModelProperty}.associationQuery('${pluralizedModelAttributeName}').all()
-    //    this.ok(${pluralizedModelAttributeName})
+    // const ${pluralizedModelAttributeName} = await ${loadQueryBase}
+    //   .preloadFor('${forAdmin ? 'adminSummary' : 'summary'}')
+    //   .all()
+    // this.ok(${pluralizedModelAttributeName})
   }`;
                 else
                     return `\
@@ -69,7 +79,7 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
   //   tags: openApiTags,
   //   description: '<tbd>',
   //   many: true,
-  //   serializerKey: 'summary',
+  //   serializerKey: '${forAdmin ? 'adminSummary' : 'summary'}',
   // })
   public async index() {
   }`;
@@ -79,11 +89,11 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
   @OpenAPI(${modelClassName}, {
     status: 200,
     tags: openApiTags,
-    description: 'Fetch ${aOrAnDreamModelName(modelClassName)}',
+    description: 'Fetch ${aOrAnDreamModelName(modelClassName)}',${defaultOpenapiSerializerKeyProperty}
   })
   public async show() {
-    //    const ${modelAttributeName} = await this.${modelAttributeName}()
-    //    this.ok(${modelAttributeName})
+    // const ${modelAttributeName} = await this.${modelAttributeName}()
+    // this.ok(${modelAttributeName})
   }`;
                 else
                     return `\
@@ -103,9 +113,9 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
     description: 'Update ${aOrAnDreamModelName(modelClassName)}',
   })
   public async update() {
-    //    const ${modelAttributeName} = await this.${modelAttributeName}()
-    //    await ${modelAttributeName}.update(this.paramsFor(${modelClassName}))
-    //    this.noContent()
+    // const ${modelAttributeName} = await this.${modelAttributeName}()
+    // await ${modelAttributeName}.update(this.paramsFor(${modelClassName}))
+    // this.noContent()
   }`;
                 else
                     return `\
@@ -125,9 +135,9 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
     description: 'Destroy ${aOrAnDreamModelName(modelClassName)}',
   })
   public async destroy() {
-    //    const ${modelAttributeName} = await this.${modelAttributeName}()
-    //    await ${modelAttributeName}.destroy()
-    //    this.noContent()
+    // const ${modelAttributeName} = await this.${modelAttributeName}()
+    // await ${modelAttributeName}.destroy()
+    // this.noContent()
   }`;
                 else
                     return `\
@@ -147,8 +157,8 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
     description: 'Fetch ${aOrAnDreamModelName(modelClassName)}',
   })
   public async ${methodName}() {
-    //    const ${modelAttributeName} = await this.${modelAttributeName}()
-    //    this.ok(${modelAttributeName})
+    // const ${modelAttributeName} = await this.${modelAttributeName}()
+    // this.ok(${modelAttributeName})
   }`;
                 else
                     return `\
@@ -167,23 +177,23 @@ function generateControllerContent({ ancestorName, ancestorImportStatement, full
 ${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(modelClassName, actions, owningModelProperty) : ''}
+${methodDefs.join('\n\n')}${modelClassName ? privateMethods(forAdmin, modelClassName, actions, loadQueryBase) : ''}
 }
 `;
 }
-function privateMethods(modelClassName, methods, owningModelProperty) {
+function privateMethods(forAdmin, modelClassName, methods, loadQueryBase) {
     const privateMethods = [];
     if (methods.find(methodName => ['show', 'update', 'destroy'].includes(methodName)))
-        privateMethods.push(loadModelStatement(modelClassName, owningModelProperty));
+        privateMethods.push(loadModelStatement(forAdmin, modelClassName, loadQueryBase));
     if (!privateMethods.length)
         return '';
     return `\n\n${privateMethods.join('\n\n')}`;
 }
-function loadModelStatement(modelClassName, owningModelProperty) {
+function loadModelStatement(forAdmin, modelClassName, loadQueryBase) {
     return `  private async ${(0, dream_1.camelize)(modelClassName)}() {
-    // return await this.${owningModelProperty}.associationQuery('${(0, pluralize_esm_1.default)((0, dream_1.camelize)(modelClassName))}').findOrFail(
-    //   this.castParam('id', 'string')
-    // )
+    // return await ${loadQueryBase}
+    //   .preloadFor('${forAdmin ? 'admin' : 'default'}')
+    //   .findOrFail(this.castParam('id', 'string'))
   }`;
 }
 function importStatementForModel(originControllerName, destinationModelName) {

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

@@ -7,75 +7,116 @@ exports.default = generateResourceControllerSpecContent;
 const dream_1 = require("@rvoh/dream");
 const relativePsychicPath_js_1 = __importDefault(require("../../helpers/path/relativePsychicPath.js"));
 const updirsFromPath_js_1 = __importDefault(require("../../helpers/path/updirsFromPath.js"));
-function generateResourceControllerSpecContent({ fullyQualifiedControllerName, route, fullyQualifiedModelName, columnsWithTypes, owningModel, }) {
+const index_js_1 = require("../../index.js");
+function generateResourceControllerSpecContent({ fullyQualifiedControllerName, route, fullyQualifiedModelName, columnsWithTypes, owningModel, forAdmin, }) {
     fullyQualifiedModelName = (0, dream_1.standardizeFullyQualifiedModelName)(fullyQualifiedModelName);
     const modelClassName = (0, dream_1.globalClassNameFromFullyQualifiedModelName)(fullyQualifiedModelName);
     const modelVariableName = (0, dream_1.camelize)(modelClassName);
     // Always use User for authentication
-    const owningModelClassName = 'User';
-    const userVariableName = 'user';
+    const userModelClassName = forAdmin ? 'AdminUser' : 'User';
+    const userVariableName = forAdmin ? 'adminUser' : 'user';
     // Determine attached model settings if provided
-    const attachedModelClassName = owningModel ? (0, dream_1.globalClassNameFromFullyQualifiedModelName)(owningModel) : null;
-    const attachedModelVariableName = attachedModelClassName ? (0, dream_1.camelize)(attachedModelClassName) : null;
-    const importStatements = [
+    const owningModelClassName = owningModel
+        ? (0, dream_1.globalClassNameFromFullyQualifiedModelName)(owningModel)
+        : userModelClassName;
+    const owningModelVariableName = owningModelClassName ? (0, dream_1.camelize)(owningModelClassName) : userVariableName;
+    const importStatements = (0, dream_1.compact)([
         importStatementForModel(fullyQualifiedControllerName, fullyQualifiedModelName),
-        importStatementForModel(fullyQualifiedControllerName, 'User'),
-        importStatementForType('openapi/validation.openapi', 'validationOpenapiPaths'),
+        importStatementForModel(fullyQualifiedControllerName, userModelClassName),
+        owningModel ? importStatementForModel(fullyQualifiedControllerName, owningModel) : undefined,
         importStatementForModelFactory(fullyQualifiedControllerName, fullyQualifiedModelName),
-        importStatementForModelFactory(fullyQualifiedControllerName, 'User'),
-    ];
-    // Add attached model imports if specified
-    if (owningModel) {
-        importStatements.push(importStatementForModel(fullyQualifiedControllerName, owningModel), importStatementForModelFactory(fullyQualifiedControllerName, owningModel));
-    }
+        importStatementForModelFactory(fullyQualifiedControllerName, userModelClassName),
+        owningModel ? importStatementForModelFactory(fullyQualifiedControllerName, owningModel) : undefined,
+    ]);
     const specUnitUpdirs = (0, updirsFromPath_js_1.default)(fullyQualifiedControllerName);
-    const originalStringKeyValues = [];
-    const updatedStringKeyValues = [];
-    const originalStringAttributeChecks = [];
-    const updatedStringAttributeChecks = [];
+    const attributeCreationKeyValues = [];
+    const attributeUpdateKeyValues = [];
+    const originalValueAttributeChecks = [];
+    const updatedValueAttributeChecks = [];
+    const nonUpdatedValueAttributeChecks = [];
+    const originalValueVariableAssignments = [];
+    const keyWithDotValue = [];
     for (const attribute of columnsWithTypes) {
-        const [attributeName, attributeType] = attribute.split(':');
+        const [rawAttributeName, attributeType, , enumValues] = attribute.split(':');
+        if (rawAttributeName === 'type')
+            continue;
+        if (/(_type|_id)$/.test(rawAttributeName ?? ''))
+            continue;
+        const attributeName = (0, dream_1.camelize)(rawAttributeName ?? '');
         const originalName = `The ${fullyQualifiedModelName} ${attributeName}`;
         const updatedName = `Updated ${fullyQualifiedModelName} ${attributeName}`;
+        const dotNotationVariable = `${modelVariableName}.${attributeName}`;
         switch (attributeType) {
+            case 'enum': {
+                if (attribute === 'type')
+                    continue;
+                const originalEnumValue = (enumValues ?? '').split(',').at(0);
+                const updatedEnumValue = (enumValues ?? '').split(',').at(-1);
+                attributeCreationKeyValues.push(`${attributeName}: '${originalEnumValue}',`);
+                attributeUpdateKeyValues.push(`${attributeName}: '${updatedEnumValue}',`);
+                originalValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual('${originalEnumValue}')`);
+                updatedValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual('${updatedEnumValue}')`);
+                break;
+            }
             case 'string':
             case 'text':
-                originalStringKeyValues.push(`${attributeName}: '${originalName}',`);
-                updatedStringKeyValues.push(`${attributeName}: '${updatedName}',`);
-                originalStringAttributeChecks.push(`expect(${modelVariableName}.${attributeName}).toEqual('${originalName}')`);
-                updatedStringAttributeChecks.push(`expect(${modelVariableName}.${attributeName}).toEqual('${updatedName}')`);
+            case 'citext':
+                attributeCreationKeyValues.push(`${attributeName}: '${originalName}',`);
+                attributeUpdateKeyValues.push(`${attributeName}: '${updatedName}',`);
+                originalValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual('${originalName}')`);
+                updatedValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual('${updatedName}')`);
+                break;
+            case 'integer':
+                attributeCreationKeyValues.push(`${attributeName}: 1,`);
+                attributeUpdateKeyValues.push(`${attributeName}: 2,`);
+                originalValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual(1)`);
+                updatedValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual(2)`);
+                break;
+            case 'bigint':
+                attributeCreationKeyValues.push(`${attributeName}: '11111111111111111',`);
+                attributeUpdateKeyValues.push(`${attributeName}: '22222222222222222',`);
+                originalValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual('11111111111111111')`);
+                updatedValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual('22222222222222222')`);
+                break;
+            case 'decimal':
+                attributeCreationKeyValues.push(`${attributeName}: 1.1,`);
+                attributeUpdateKeyValues.push(`${attributeName}: 2.2,`);
+                originalValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual(1.1)`);
+                updatedValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual(2.2)`);
                 break;
             default:
-            // noop
+                continue;
         }
+        keyWithDotValue.push(`${attributeName}: ${dotNotationVariable},`);
+        const originalAttributeVariableName = 'original' + (0, dream_1.capitalize)(attributeName);
+        originalValueVariableAssignments.push(`const ${originalAttributeVariableName} = ${dotNotationVariable}`);
+        nonUpdatedValueAttributeChecks.push(`expect(${dotNotationVariable}).toEqual(${originalAttributeVariableName})`);
     }
+    const simpleCreationCommand = `const ${modelVariableName} = await create${modelClassName}(${forAdmin ? '' : `{ ${owningModelVariableName} }`})`;
+    const dotValueAttributes = keyWithDotValue.length
+        ? '\n          ' + keyWithDotValue.join('\n          ')
+        : '';
     return `\
-import { UpdateableProperties } from '@rvoh/dream'
-import { PsychicServer } from '@rvoh/psychic'
-import { OpenapiSpecRequest } from '@rvoh/psychic-spec-helpers'${(0, dream_1.uniq)(importStatements).join('')}
-import addEndUserAuthHeader from '${specUnitUpdirs}helpers/authentication.js'
-
-const request = new OpenapiSpecRequest<validationOpenapiPaths>()
+import { UpdateableProperties } from '@rvoh/dream'${(0, dream_1.uniq)(importStatements).join('')}
+import { session, SpecRequestType } from '${specUnitUpdirs}helpers/authentication.js'
 
 describe('${fullyQualifiedControllerName}', () => {
-  let ${userVariableName}: ${owningModelClassName}${attachedModelVariableName ? `\n  let ${attachedModelVariableName}: ${attachedModelClassName}` : ''}
+  let request: SpecRequestType
+  let ${userVariableName}: ${userModelClassName}${owningModel ? `\n  let ${owningModelVariableName}: ${owningModelClassName}` : ''}
 
   beforeEach(async () => {
-    await request.init(PsychicServer)
-    ${userVariableName} = await createUser()${attachedModelVariableName ? `\n    ${attachedModelVariableName} = await create${attachedModelClassName}({ ${userVariableName} })` : ''}
+    ${userVariableName} = await create${userModelClassName}()${owningModel ? `\n    ${owningModelVariableName} = await create${owningModelClassName}({ ${userVariableName} })` : ''}
+    request = await session(${userVariableName})
   })
 
   describe('GET index', () => {
     const subject = async <StatusCode extends 200 | 400>(expectedStatus: StatusCode) => {
-      return request.get('/${route}', expectedStatus, {
-        headers: await addEndUserAuthHeader(request, ${userVariableName}, {}),
-      })
+      return request.get('/${route}', expectedStatus)
     }
 
     it('returns the index of ${fullyQualifiedModelName}s', async () => {
-      const ${modelVariableName} = await create${modelClassName}({
-        ${attachedModelVariableName || userVariableName}${originalStringKeyValues.length ? ',\n        ' + originalStringKeyValues.join('\n        ') : ''}
-      })
+      ${simpleCreationCommand}
+
       const { body } = await subject(200)
 
       expect(body).toEqual([
@@ -83,45 +124,49 @@ describe('${fullyQualifiedControllerName}', () => {
           id: ${modelVariableName}.id,
         }),
       ])
-    })
+    })${forAdmin
+        ? ''
+        : `
 
     context('${modelClassName}s created by another ${owningModelClassName}', () => {
       it('are omitted', async () => {
         await create${modelClassName}()
+
         const { body } = await subject(200)
 
         expect(body).toEqual([])
       })
-    })
+    })`}
   })
 
   describe('GET show', () => {
     const subject = async <StatusCode extends 200 | 400 | 404>(${modelVariableName}: ${modelClassName}, expectedStatus: StatusCode) => {
       return request.get('/${route}/{id}', expectedStatus, {
         id: ${modelVariableName}.id,
-        headers: await addEndUserAuthHeader(request, ${userVariableName}, {}),
       })
     }
 
     it('returns the specified ${fullyQualifiedModelName}', async () => {
-      const ${modelVariableName} = await create${modelClassName}({
-        ${attachedModelVariableName || userVariableName}${originalStringKeyValues.length ? ',\n        ' + originalStringKeyValues.join('\n        ') : ''}
-      })
+      ${simpleCreationCommand}
+
       const { body } = await subject(${modelVariableName}, 200)
 
       expect(body).toEqual(
         expect.objectContaining({
-          id: ${modelVariableName}.id,${originalStringKeyValues.length ? '\n          ' + originalStringKeyValues.join('\n          ') : ''}
+          id: ${modelVariableName}.id,${dotValueAttributes}
         }),
       )
-    })
+    })${forAdmin
+        ? ''
+        : `
 
     context('${fullyQualifiedModelName} created by another ${owningModelClassName}', () => {
       it('is not found', async () => {
         const other${owningModelClassName}${modelClassName} = await create${modelClassName}()
+
         await subject(other${owningModelClassName}${modelClassName}, 404)
       })
-    })
+    })`}
   })
 
   describe('POST create', () => {
@@ -129,21 +174,21 @@ describe('${fullyQualifiedControllerName}', () => {
       data: UpdateableProperties<${modelClassName}>,
       expectedStatus: StatusCode
     ) => {
-      return request.post('/${route}', expectedStatus, {
-        data,
-        headers: await addEndUserAuthHeader(request, ${userVariableName}, {}),
-      })
+      return request.post('/${route}', expectedStatus, { data })
     }
 
-    it('creates a ${fullyQualifiedModelName} for this ${owningModelClassName}', async () => {
+    it('creates a ${fullyQualifiedModelName}${forAdmin ? '' : ` for this ${owningModelClassName}`}', async () => {
       const { body } = await subject({
-        ${originalStringKeyValues.length ? originalStringKeyValues.join('\n        ') : ''}
+        ${attributeCreationKeyValues.join('\n        ')}
       }, 201)
-      const ${modelVariableName} = await ${modelClassName}.findOrFailBy({ ${userVariableName}Id: ${userVariableName}.id })
+
+      const ${modelVariableName} = await ${forAdmin
+        ? `${modelClassName}.firstOrFail()`
+        : `${owningModelVariableName}.associationQuery('${(0, index_js_1.pluralize)(modelVariableName)}').firstOrFail()`}
 
       expect(body).toEqual(
         expect.objectContaining({
-          id: ${modelVariableName}.id,${originalStringKeyValues.length ? '\n          ' + originalStringKeyValues.join('\n          ') : ''}
+          id: ${modelVariableName}.id,${attributeCreationKeyValues.length ? '\n          ' + attributeCreationKeyValues.join('\n          ') : ''}
         }),
       )
     })
@@ -158,58 +203,63 @@ describe('${fullyQualifiedControllerName}', () => {
       return request.patch('/${route}/{id}', expectedStatus, {
         id: ${modelVariableName}.id,
         data,
-        headers: await addEndUserAuthHeader(request, ${userVariableName}, {}),
       })
     }
 
     it('updates the ${fullyQualifiedModelName}', async () => {
-      const ${modelVariableName} = await create${modelClassName}({
-        ${attachedModelVariableName || userVariableName}${originalStringKeyValues.length ? ',\n        ' + originalStringKeyValues.join('\n        ') : ''}
-      })
+      ${simpleCreationCommand}
+
       await subject(${modelVariableName}, {
-        ${updatedStringKeyValues.length ? updatedStringKeyValues.join('\n        ') : ''}
+        ${attributeUpdateKeyValues.length ? attributeUpdateKeyValues.join('\n        ') : ''}
       }, 204)
 
       await ${modelVariableName}.reload()
-      ${updatedStringAttributeChecks.join('\n      ')}
-    })
+      ${updatedValueAttributeChecks.join('\n      ')}
+    })${forAdmin
+        ? ''
+        : `
 
     context('a ${fullyQualifiedModelName} created by another ${owningModelClassName}', () => {
       it('is not updated', async () => {
         const ${modelVariableName} = await create${modelClassName}()
+        ${originalValueVariableAssignments.length ? originalValueVariableAssignments.join('\n        ') : ''}
+
         await subject(${modelVariableName}, {
-          ${updatedStringKeyValues.length ? updatedStringKeyValues.join('\n          ') : ''}
+          ${attributeUpdateKeyValues.length ? attributeUpdateKeyValues.join('\n          ') : ''}
         }, 404)
 
         await ${modelVariableName}.reload()
-        ${originalStringAttributeChecks.join('\n        ')}
+        ${nonUpdatedValueAttributeChecks.join('\n        ')}
       })
-    })
+    })`}
   })
 
   describe('DELETE destroy', () => {
     const subject = async <StatusCode extends 204 | 400 | 404>(${modelVariableName}: ${modelClassName}, expectedStatus: StatusCode) => {
       return request.delete('/${route}/{id}', expectedStatus, {
         id: ${modelVariableName}.id,
-        headers: await addEndUserAuthHeader(request, ${userVariableName}, {}),
       })
     }
 
     it('deletes the ${fullyQualifiedModelName}', async () => {
-      const ${modelVariableName} = await create${modelClassName}({ ${attachedModelVariableName || userVariableName} })
+      ${simpleCreationCommand}
+
       await subject(${modelVariableName}, 204)
 
       expect(await ${modelClassName}.find(${modelVariableName}.id)).toBeNull()
-    })
+    })${forAdmin
+        ? ''
+        : `
 
     context('a ${fullyQualifiedModelName} created by another ${owningModelClassName}', () => {
       it('is not deleted', async () => {
         const ${modelVariableName} = await create${modelClassName}()
+
         await subject(${modelVariableName}, 404)
 
         expect(await ${modelClassName}.find(${modelVariableName}.id)).toMatchDreamModel(${modelVariableName})
       })
-    })
+    })`}
   })
 })
 `;
@@ -217,10 +267,6 @@ describe('${fullyQualifiedControllerName}', () => {
 function importStatementForModel(originModelName, destinationModelName = originModelName) {
     return `\nimport ${(0, dream_1.globalClassNameFromFullyQualifiedModelName)(destinationModelName)} from '${(0, relativePsychicPath_js_1.default)('controllerSpecs', 'models', originModelName, destinationModelName)}'`;
 }
-function importStatementForType(typeFilePath, typeExportName) {
-    const importPath = (0, relativePsychicPath_js_1.default)('controllerSpecs', 'types', typeFilePath).toLowerCase();
-    return `\nimport { ${typeExportName} } from '${importPath}'`;
-}
 function importStatementForModelFactory(originModelName, destinationModelName = originModelName) {
     return `\nimport create${(0, dream_1.globalClassNameFromFullyQualifiedModelName)(destinationModelName)} from '${(0, relativePsychicPath_js_1.default)('controllerSpecs', 'factories', originModelName, destinationModelName)}'`;
 }