Allow adding and updating fields with expressions in default values

src/utils/field.ts

@@ -153,6 +153,7 @@ export const diffFields = async (
     fieldsToAdd,
     modelSlug,
     definedFields,
+    existingFields,
     options,
   );
 
@@ -352,6 +353,7 @@ export const createFields = async (
   fields: Array<ModelField>,
   modelSlug: string,
   definedFields?: Array<ModelField>,
+  existingFields?: Array<ModelField>,
   options?: MigrationOptions,
 ): Promise<Array<string>> => {
   const diff: Array<string> = [];
@@ -401,6 +403,7 @@ export const createFields = async (
         },
       );
     }
+
     // Handle required fields by prompting for default value since SQLite doesn't allow
     // adding NOT NULL columns without defaults.
     if (fieldToAdd.required && !fieldToAdd.defaultValue) {
@@ -425,9 +428,25 @@ export const createFields = async (
       );
       return diff;
     }
+
+    // If the field contains an expression as default value, we need to create a temporary
+    // model with the existing fields and the new field.
+    if (fieldToAdd.defaultValue && typeof fieldToAdd.defaultValue === 'object') {
+      diff.push(
+        ...createTempModelQuery(
+          {
+            slug: modelSlug,
+            // @ts-expect-error This will work once the types are fixed.
+            fields: convertArrayToObject(definedFields),
+          },
+          { includeFields: existingFields },
+        ),
+      );
+      return diff;
+    }
+
     diff.push(createFieldQuery(modelSlug, fieldToAdd));
   }
-
   return diff;
 };
 

src/utils/migration.ts

@@ -22,12 +22,12 @@ import type { Model } from '@ronin/compiler';
 /**
  * Options for migration operations.
  */
-export type MigrationOptions = {
+export interface MigrationOptions {
   rename?: boolean;
   requiredDefault?: boolean | string;
   name?: string;
   pluralName?: string;
-};
+}
 
 /**
  * Fields to ignore.

tests/fixtures/utils.ts

@@ -122,7 +122,7 @@ export const runMigration = async (
  * @returns The number of records in the table.
  */
 export const getRowCount = async (db: Database, modelSlug: string): Promise<number> => {
-  const res = await db.query([`SELECT COUNT(*) FROM ${modelSlug};`]);
+  const res = await db.query([`SELECT COUNT(*) FROM "${modelSlug}";`]);
   return res[0].rows[0]['COUNT(*)'];
 };
 

tests/utils/apply.test.ts

@@ -32,7 +32,7 @@ import {
 import { getRowCount, getSQLTables, getTableRows, runMigration } from '@/fixtures/utils';
 import { getLocalPackages } from '@/src/utils/misc';
 import type { Model } from 'ronin/schema';
-import { model, string } from 'ronin/schema';
+import { model, number, random, string } from 'ronin/schema';
 const packages = await getLocalPackages();
 const { Transaction } = packages.compiler;
 
@@ -348,6 +348,48 @@ describe('apply', () => {
             tests: 0,
           });
         });
+
+        test('add field with expression as default value', async () => {
+          const ModelA = model({
+            slug: 'a',
+            fields: {
+              name: string(),
+            },
+          }) as unknown as Model;
+
+          const ModelB = model({
+            slug: 'a',
+            fields: {
+              name: string(),
+              age: number().defaultValue(() => random()),
+            },
+          }) as unknown as Model;
+
+          // @ts-expect-error This works once the types are fixed.
+          const { models, db, modelDiff } = await runMigration([ModelB], [ModelA], {
+            requiredDefault: 'RONIN_TEST_VALUE',
+          });
+
+          const rowCounts: Record<string, number> = {};
+          for (const model of models) {
+            if (model.pluralSlug) {
+              rowCounts[model.pluralSlug] = await getRowCount(db, model.pluralSlug);
+            }
+          }
+
+          expect(modelDiff[0]).toContain(
+            'create.model({"slug":"RONIN_TEMP_a","fields":{"name":{"type":"string"},"age":{"type":"number","defaultValue":{"__RONIN_EXPRESSION":"random()"}}}})',
+          );
+
+          expect(models).toHaveLength(1);
+          // @ts-expect-error This is defined!
+          expect(models[0]?.fields[1].defaultValue).toEqual({
+            __RONIN_EXPRESSION: 'random()',
+          });
+          expect(rowCounts).toEqual({
+            as: 0,
+          });
+        });
       });
 
       describe('drop', () => {
@@ -426,6 +468,49 @@ describe('apply', () => {
             tests: 0,
           });
         });
+
+        test('update field with expression as default value', async () => {
+          const ModelA = model({
+            slug: 'a',
+            fields: {
+              name: string(),
+              age: number().defaultValue(() => 25),
+            },
+          }) as unknown as Model;
+
+          const ModelB = model({
+            slug: 'a',
+            fields: {
+              name: string(),
+              age: number().defaultValue(() => random()),
+            },
+          }) as unknown as Model;
+
+          // @ts-expect-error This works once the types are fixed.
+          const { models, db, modelDiff } = await runMigration([ModelB], [ModelA], {
+            requiredDefault: 'RONIN_TEST_VALUE',
+          });
+
+          const rowCounts: Record<string, number> = {};
+          for (const model of models) {
+            if (model.pluralSlug) {
+              rowCounts[model.pluralSlug] = await getRowCount(db, model.pluralSlug);
+            }
+          }
+
+          expect(modelDiff[0]).toContain(
+            'alter.model(\'a\').create.field({"slug":"RONIN_TEMP_age","type":"number","defaultValue":{"__RONIN_EXPRESSION":"random()"}})',
+          );
+
+          expect(models).toHaveLength(1);
+          // @ts-expect-error This is defined!
+          expect(models[0]?.fields[1].defaultValue).toEqual({
+            __RONIN_EXPRESSION: 'random()',
+          });
+          expect(rowCounts).toEqual({
+            as: 0,
+          });
+        });
       });
     });
 
@@ -503,6 +588,7 @@ describe('apply', () => {
           expect(rowCounts).toEqual({
             accounts: 1,
           });
+
           expect(rows[0].email).toBe('RONIN_TEST_VALUE');
         });
 
@@ -522,24 +608,29 @@ describe('apply', () => {
             inlineParams: true,
           });
 
-          const { models, db } = await runMigration(
+          const { models, db, modelDiff } = await runMigration(
             [AccountWithRequiredDefault],
             [Account],
             { rename: false, requiredDefault: 'RONIN_TEST_VALUE' },
             transaction.statements.map((statement) => statement),
           );
 
-          const rows = await getTableRows(db, Account3);
+          await db.query(transaction.statements);
+
+          const rows = await getTableRows(db, AccountWithRequiredDefault);
 
           const rowCounts: Record<string, number> = {};
           for (const model of models) {
             if (model.pluralSlug) {
               rowCounts[model.pluralSlug] = await getRowCount(db, model.pluralSlug);
             }
           }
+
+          expect(modelDiff).toHaveLength(1);
           expect(rowCounts).toEqual({
-            accounts: 1,
+            accounts: 2,
           });
+
           expect(rows[0].email).toBe('RONIN_TEST_VALUE_REQUIRED_DEFAULT');
         });