several improvements

- transform DateTime values from string to Date before return
- support `@default` and `@default(auth()...)`

Author: ymc9

packages/plugins/swr/src/generator.ts

@@ -10,7 +10,7 @@ import {
     resolvePath,
     saveProject,
 } from '@zenstackhq/sdk';
-import { DataModel, DataModelFieldType, Model, isEnum } from '@zenstackhq/sdk/ast';
+import { DataModel, DataModelFieldType, Model, isEnum, isTypeDef } from '@zenstackhq/sdk/ast';
 import { getPrismaClientImportSpec, supportCreateMany, type DMMF } from '@zenstackhq/sdk/prisma';
 import { paramCase } from 'change-case';
 import path from 'path';
@@ -28,8 +28,9 @@ export async function generate(model: Model, options: PluginOptions, dmmf: DMMF.
     const warnings: string[] = [];
 
     const models = getDataModels(model);
+    const typeDefs = model.declarations.filter(isTypeDef);
 
-    await generateModelMeta(project, models, {
+    await generateModelMeta(project, models, typeDefs, {
         output: path.join(outDir, '__model_meta.ts'),
         generateAttributes: false,
     });

packages/plugins/tanstack-query/src/generator.ts

@@ -11,7 +11,7 @@ import {
     resolvePath,
     saveProject,
 } from '@zenstackhq/sdk';
-import { DataModel, DataModelFieldType, Model, isEnum } from '@zenstackhq/sdk/ast';
+import { DataModel, DataModelFieldType, Model, isEnum, isTypeDef } from '@zenstackhq/sdk/ast';
 import { getPrismaClientImportSpec, supportCreateMany, type DMMF } from '@zenstackhq/sdk/prisma';
 import { paramCase } from 'change-case';
 import { lowerCaseFirst } from 'lower-case-first';
@@ -29,6 +29,7 @@ export async function generate(model: Model, options: PluginOptions, dmmf: DMMF.
     const project = createProject();
     const warnings: string[] = [];
     const models = getDataModels(model);
+    const typeDefs = model.declarations.filter(isTypeDef);
 
     const target = requireOption<string>(options, 'target', name);
     if (!supportedTargets.includes(target)) {
@@ -44,7 +45,7 @@ export async function generate(model: Model, options: PluginOptions, dmmf: DMMF.
     outDir = resolvePath(outDir, options);
     ensureEmptyDir(outDir);
 
-    await generateModelMeta(project, models, {
+    await generateModelMeta(project, models, typeDefs, {
         output: path.join(outDir, '__model_meta.ts'),
         generateAttributes: false,
     });

packages/runtime/src/cross/model-meta.ts

@@ -44,6 +44,11 @@ export type FieldInfo = {
      */
     isDataModel?: boolean;
 
+    /**
+     * If the field type is a type def (or an optional/array of type def)
+     */
+    isTypeDef?: boolean;
+
     /**
      * If the field is an array
      */
@@ -143,6 +148,21 @@ export type ModelInfo = {
     discriminator?: string;
 };
 
+/**
+ * Metadata for a type def
+ */
+export type TypeDefInfo = {
+    /**
+     * TypeDef name
+     */
+    name: string;
+
+    /**
+     * Fields
+     */
+    fields: Record<string, FieldInfo>;
+};
+
 /**
  * ZModel data model metadata
  */
@@ -152,6 +172,11 @@ export type ModelMeta = {
      */
     models: Record<string, ModelInfo>;
 
+    /**
+     * Type defs
+     */
+    typeDefs?: Record<string, TypeDefInfo>;
+
     /**
      * Mapping from model name to models that will be deleted because of it due to cascade delete
      */
@@ -171,15 +196,21 @@ export type ModelMeta = {
 /**
  * Resolves a model field to its metadata. Returns undefined if not found.
  */
-export function resolveField(modelMeta: ModelMeta, model: string, field: string): FieldInfo | undefined {
-    return modelMeta.models[lowerCaseFirst(model)]?.fields?.[field];
+export function resolveField(
+    modelMeta: ModelMeta,
+    modelOrTypeDef: string,
+    field: string,
+    isTypeDef = false
+): FieldInfo | undefined {
+    const container = isTypeDef ? modelMeta.typeDefs : modelMeta.models;
+    return container?.[lowerCaseFirst(modelOrTypeDef)]?.fields?.[field];
 }
 
 /**
  * Resolves a model field to its metadata. Throws an error if not found.
  */
-export function requireField(modelMeta: ModelMeta, model: string, field: string) {
-    const f = resolveField(modelMeta, model, field);
+export function requireField(modelMeta: ModelMeta, model: string, field: string, isTypeDef = false) {
+    const f = resolveField(modelMeta, model, field, isTypeDef);
     if (!f) {
         throw new Error(`Field ${model}.${field} cannot be resolved`);
     }

packages/runtime/src/cross/utils.ts

@@ -1,5 +1,5 @@
 import { lowerCaseFirst } from 'lower-case-first';
-import { requireField, type ModelInfo, type ModelMeta } from '.';
+import { requireField, type ModelInfo, type ModelMeta, type TypeDefInfo } from '.';
 
 /**
  * Gets field names in a data model entity, filtering out internal fields.
@@ -46,6 +46,9 @@ export function zip<T1, T2>(x: Enumerable<T1>, y: Enumerable<T2>): Array<[T1, T2
     }
 }
 
+/**
+ * Gets ID fields of a model.
+ */
 export function getIdFields(modelMeta: ModelMeta, model: string, throwIfNotFound = false) {
     const uniqueConstraints = modelMeta.models[lowerCaseFirst(model)]?.uniqueConstraints ?? {};
 
@@ -60,6 +63,9 @@ export function getIdFields(modelMeta: ModelMeta, model: string, throwIfNotFound
     return entries[0].fields.map((f) => requireField(modelMeta, model, f));
 }
 
+/**
+ * Gets info for a model.
+ */
 export function getModelInfo<Throw extends boolean = false>(
     modelMeta: ModelMeta,
     model: string,
@@ -72,6 +78,25 @@ export function getModelInfo<Throw extends boolean = false>(
     return info;
 }
 
+/**
+ * Gets info for a type def.
+ */
+export function getTypeDefInfo<Throw extends boolean = false>(
+    modelMeta: ModelMeta,
+    typeDef: string,
+    throwIfNotFound: Throw = false as Throw
+): Throw extends true ? TypeDefInfo : TypeDefInfo | undefined {
+    const info = modelMeta.typeDefs?.[lowerCaseFirst(typeDef)];
+    if (!info && throwIfNotFound) {
+        throw new Error(`Unable to load info for ${typeDef}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return info as any;
+}
+
+/**
+ * Checks if a model is a delegate model.
+ */
 export function isDelegateModel(modelMeta: ModelMeta, model: string) {
     return !!getModelInfo(modelMeta, model)?.attributes?.some((attr) => attr.name === '@@delegate');
 }

packages/runtime/src/enhancements/edge/json-processor.ts

@@ -0,0 +1 @@
+../node/json-processor.ts

packages/runtime/src/enhancements/node/create-enhancement.ts

@@ -10,6 +10,7 @@ import type {
 } from '../../types';
 import { withDefaultAuth } from './default-auth';
 import { withDelegate } from './delegate';
+import { withJsonProcessor } from './json-processor';
 import { Logger } from './logger';
 import { withOmit } from './omit';
 import { withPassword } from './password';
@@ -90,10 +91,18 @@ export function createEnhancement<DbClient extends object>(
 
     // TODO: move the detection logic into each enhancement
     // TODO: how to properly cache the detection result?
+
     const allFields = Object.values(options.modelMeta.models).flatMap((modelInfo) => Object.values(modelInfo.fields));
+    if (options.modelMeta.typeDefs) {
+        allFields.push(
+            ...Object.values(options.modelMeta.typeDefs).flatMap((typeDefInfo) => Object.values(typeDefInfo.fields))
+        );
+    }
+
     const hasPassword = allFields.some((field) => field.attributes?.some((attr) => attr.name === '@password'));
     const hasOmit = allFields.some((field) => field.attributes?.some((attr) => attr.name === '@omit'));
     const hasDefaultAuth = allFields.some((field) => field.defaultValueProvider);
+    const hasTypeDefField = allFields.some((field) => field.isTypeDef);
 
     const kinds = options.kinds ?? ALL_ENHANCEMENTS;
     let result = prisma;
@@ -142,5 +151,9 @@ export function createEnhancement<DbClient extends object>(
         result = withOmit(result, options);
     }
 
+    if (hasTypeDefField) {
+        result = withJsonProcessor(result, options);
+    }
+
     return result;
 }

packages/runtime/src/enhancements/node/default-auth.ts

@@ -8,6 +8,7 @@ import {
     clone,
     enumerate,
     getFields,
+    getTypeDefInfo,
     requireField,
 } from '../../cross';
 import { DbClientContract, EnhancementContext } from '../../types';
@@ -70,6 +71,11 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
         const processCreatePayload = (model: string, data: any) => {
             const fields = getFields(this.options.modelMeta, model);
             for (const fieldInfo of Object.values(fields)) {
+                if (fieldInfo.isTypeDef) {
+                    this.setDefaultValueForTypeDefData(fieldInfo.type, data[fieldInfo.name]);
+                    continue;
+                }
+
                 if (fieldInfo.name in data) {
                     // create payload already sets field value
                     continue;
@@ -80,10 +86,10 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
                     continue;
                 }
 
-                const authDefaultValue = this.getDefaultValueFromAuth(fieldInfo);
-                if (authDefaultValue !== undefined) {
+                const defaultValue = this.getDefaultValue(fieldInfo);
+                if (defaultValue !== undefined) {
                     // set field value extracted from `auth()`
-                    this.setAuthDefaultValue(fieldInfo, model, data, authDefaultValue);
+                    this.setDefaultValueForModelData(fieldInfo, model, data, defaultValue);
                 }
             }
         };
@@ -109,7 +115,7 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
         return newArgs;
     }
 
-    private setAuthDefaultValue(fieldInfo: FieldInfo, model: string, data: any, authDefaultValue: unknown) {
+    private setDefaultValueForModelData(fieldInfo: FieldInfo, model: string, data: any, authDefaultValue: unknown) {
         if (fieldInfo.isForeignKey && fieldInfo.relationField && fieldInfo.relationField in data) {
             // if the field is a fk, and the relation field is already set, we should not override it
             return;
@@ -155,7 +161,7 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
         return entry?.[0];
     }
 
-    private getDefaultValueFromAuth(fieldInfo: FieldInfo) {
+    private getDefaultValue(fieldInfo: FieldInfo) {
         if (!this.userContext) {
             throw prismaClientValidationError(
                 this.prisma,
@@ -165,4 +171,34 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
         }
         return fieldInfo.defaultValueProvider?.(this.userContext);
     }
+
+    private setDefaultValueForTypeDefData(type: string, data: any) {
+        if (!data || (typeof data !== 'object' && !Array.isArray(data))) {
+            return;
+        }
+
+        const typeDef = getTypeDefInfo(this.options.modelMeta, type);
+        if (!typeDef) {
+            return;
+        }
+
+        enumerate(data).forEach((item) => {
+            if (!item || typeof item !== 'object') {
+                return;
+            }
+
+            for (const fieldInfo of Object.values(typeDef.fields)) {
+                if (fieldInfo.isTypeDef) {
+                    // recurse
+                    this.setDefaultValueForTypeDefData(fieldInfo.type, item[fieldInfo.name]);
+                } else if (!(fieldInfo.name in item)) {
+                    // set default value if the payload doesn't set the field
+                    const defaultValue = this.getDefaultValue(fieldInfo);
+                    if (defaultValue !== undefined) {
+                        item[fieldInfo.name] = defaultValue;
+                    }
+                }
+            }
+        });
+    }
 }

packages/runtime/src/enhancements/node/json-processor.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { enumerate, getModelFields, resolveField } from '../../cross';
+import { DbClientContract } from '../../types';
+import { InternalEnhancementOptions } from './create-enhancement';
+import { DefaultPrismaProxyHandler, makeProxy, PrismaProxyActions } from './proxy';
+import { QueryUtils } from './query-utils';
+
+/**
+ * Gets an enhanced Prisma client that post-processes JSON values.
+ *
+ * @private
+ */
+export function withJsonProcessor<DbClient extends object = any>(
+    prisma: DbClient,
+    options: InternalEnhancementOptions
+): DbClient {
+    return makeProxy(
+        prisma,
+        options.modelMeta,
+        (_prisma, model) => new JsonProcessorHandler(_prisma as DbClientContract, model, options),
+        'json-processor'
+    );
+}
+
+class JsonProcessorHandler extends DefaultPrismaProxyHandler {
+    private queryUtils: QueryUtils;
+
+    constructor(prisma: DbClientContract, model: string, options: InternalEnhancementOptions) {
+        super(prisma, model, options);
+        this.queryUtils = new QueryUtils(prisma, options);
+    }
+
+    protected override async processResultEntity<T>(_method: PrismaProxyActions, data: T): Promise<T> {
+        for (const value of enumerate(data)) {
+            await this.doPostProcess(value, this.model);
+        }
+        return data;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private async doPostProcess(entityData: any, model: string) {
+        const realModel = this.queryUtils.getDelegateConcreteModel(model, entityData);
+
+        for (const field of getModelFields(entityData)) {
+            const fieldInfo = await resolveField(this.options.modelMeta, realModel, field);
+            if (!fieldInfo) {
+                continue;
+            }
+
+            if (fieldInfo.isTypeDef) {
+                this.fixJsonDateFields(entityData[field], fieldInfo.type);
+            } else if (fieldInfo.isDataModel) {
+                const items =
+                    fieldInfo.isArray && Array.isArray(entityData[field]) ? entityData[field] : [entityData[field]];
+                for (const item of items) {
+                    // recurse
+                    await this.doPostProcess(item, fieldInfo.type);
+                }
+            }
+        }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private fixJsonDateFields(entityData: any, typeDef: string) {
+        if (typeof entityData !== 'object' && !Array.isArray(entityData)) {
+            return;
+        }
+
+        enumerate(entityData).forEach((item) => {
+            if (!item || typeof item !== 'object') {
+                return;
+            }
+
+            for (const [key, value] of Object.entries(item)) {
+                const fieldInfo = resolveField(this.options.modelMeta, typeDef, key, true);
+                if (!fieldInfo) {
+                    continue;
+                }
+                if (fieldInfo.isTypeDef) {
+                    // recurse
+                    this.fixJsonDateFields(value, fieldInfo.type);
+                } else if (fieldInfo.type === 'DateTime' && typeof value === 'string') {
+                    // convert to Date
+                    const parsed = Date.parse(value);
+                    if (!isNaN(parsed)) {
+                        item[key] = new Date(parsed);
+                    }
+                }
+            }
+        });
+    }
+}