feat: fields argument for @updatedAt

Author: sanny-io

packages/language/res/stdlib.zmodel

@@ -405,9 +405,13 @@ attribute @omit()
  *
  * @param ignore: A list of field names that are not considered when the ORM client is determining whether any
  * updates have been made to a record. An update that only contains ignored fields does not change the
- * timestamp.
+ * timestamp. Mutually exclusive with the `fields` parameter.
+
+ * @param fields: A list of field names that are considered when the ORM client is determining whether any
+ * updates have been made to a record. The timestamp will only change when any of the specified fields
+ * are updated. Mutually exclusive with the `ignore` parameter.
  */
-attribute @updatedAt(ignore: FieldReference[]?) @@@targetField([DateTimeField]) @@@prisma
+attribute @updatedAt(ignore: FieldReference[]?, fields: FieldReference[]?) @@@targetField([DateTimeField]) @@@prisma
 
 /**
  * Add full text index (MySQL only).

packages/language/src/validators/attribute-application-validator.ts

@@ -280,6 +280,15 @@ export default class AttributeApplicationValidator implements AstValidator<Attri
         }
     }
 
+    @check('@updatedAt')
+    private _checkUpdatedAt(attr: AttributeApplication, accept: ValidationAcceptor) {
+        const ignoreArg = attr.args.find(arg => arg.$resolvedParam.name === 'ignore');
+        const fieldsArg = attr.args.find(arg => arg.$resolvedParam.name === 'fields');
+        if (ignoreArg && fieldsArg) {
+            accept('error', `\`ignore\` and \`fields\` are mutually exclusive`, { node: attr.$container });
+        }
+    }
+
     @check('@@validate')
     private _checkValidate(attr: AttributeApplication, accept: ValidationAcceptor) {
         const condition = attr.args[0]?.value;

packages/orm/src/client/crud/operations/base.ts

@@ -1149,14 +1149,29 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
         const autoUpdatedFields: string[] = [];
         for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
             if (fieldDef.updatedAt && finalData[fieldName] === undefined) {
-                const ignoredFields = new Set(typeof fieldDef.updatedAt === 'boolean' ? [] : fieldDef.updatedAt.ignore);
-                const hasNonIgnoredFields = Object.keys(data).some(
-                    (field) =>
-                        (isScalarField(this.schema, modelDef.name, field) ||
-                            isForeignKeyField(this.schema, modelDef.name, field)) &&
-                        !ignoredFields.has(field),
-                );
-                if (hasNonIgnoredFields) {
+                let hasUpdated = true;
+                if (typeof fieldDef.updatedAt === 'object') {
+                    if (fieldDef.updatedAt.ignore) {
+                        const ignoredFields = new Set(fieldDef.updatedAt.ignore);
+                        const hasNonIgnoredFields = Object.keys(data).some(
+                            (field) =>
+                                (isScalarField(this.schema, modelDef.name, field) ||
+                                    isForeignKeyField(this.schema, modelDef.name, field)) &&
+                                !ignoredFields.has(field),
+                        );
+                        hasUpdated = hasNonIgnoredFields;
+                    } else if (fieldDef.updatedAt.fields) {
+                        const targetFields = new Set(fieldDef.updatedAt.fields);
+                        const hasAnyTargetFields = Object.keys(data).some(
+                            (field) =>
+                                (isScalarField(this.schema, modelDef.name, field) ||
+                                    isForeignKeyField(this.schema, modelDef.name, field)) &&
+                                targetFields.has(field),
+                        );
+                        hasUpdated = hasAnyTargetFields;
+                    }
+                }
+                if (hasUpdated) {
                     if (finalData === data) {
                         finalData = clone(data);
                     }

packages/schema/src/schema.ts

@@ -61,6 +61,7 @@ export type RelationInfo = {
 
 export type UpdatedAtInfo = {
     ignore?: readonly string[];
+    fields?: readonly string[];
 };
 
 export type FieldDef = {

packages/sdk/src/ts-schema-generator.ts

@@ -522,10 +522,10 @@ export class TsSchemaGenerator {
         );
     }
 
-    private createUpdatedAtObject(ignoreArg: AttributeArg) {
+    private createUpdatedAtObject(arg: AttributeArg) {
         return ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment('ignore', ts.factory.createArrayLiteralExpression(
-                (ignoreArg.value as ArrayExpr).items.map((item) => ts.factory.createStringLiteral((item as ReferenceExpr).target.$refText))
+            ts.factory.createPropertyAssignment(arg.$resolvedParam.name, ts.factory.createArrayLiteralExpression(
+                (arg.value as ArrayExpr).items.map((item) => ts.factory.createStringLiteral((item as ReferenceExpr).target.$refText))
             ))
         ]);
     }
@@ -575,9 +575,10 @@ export class TsSchemaGenerator {
         const updatedAtAttrib = getAttribute(field, '@updatedAt') as DataFieldAttribute | undefined;
         if (updatedAtAttrib) {
             const ignoreArg = updatedAtAttrib.args.find(arg => arg.$resolvedParam?.name === 'ignore');
+            const fieldsArg = updatedAtAttrib.args.find(arg => arg.$resolvedParam?.name === 'fields');
             objectFields.push(ts.factory.createPropertyAssignment('updatedAt',
-                ignoreArg
-                    ? this.createUpdatedAtObject(ignoreArg)
+                (ignoreArg || fieldsArg)
+                    ? this.createUpdatedAtObject(ignoreArg ?? fieldsArg!)
                     : ts.factory.createTrue()
             ));
         }