considering auth() without selector

Author: Azzerty23

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

@@ -3,7 +3,7 @@ import { lowerCaseFirst } from 'lower-case-first';
 /**
  * An access key in the user context object (e.g. `profile.picture.url`)
  */
-export type AuthContextSelector = string | undefined;
+export type AuthContextSelector = string;
 
 /**
  * Runtime information of a data model or field attribute

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

@@ -56,16 +56,21 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
                     throw new Error(`Invalid user context`);
                 }
                 const fields = this.options.modelMeta.fields[model];
-                const defaultAuthSelectorFields: Record<string, AuthContextSelector> = Object.fromEntries(
-                    Object.entries(fields)
-                        .filter(([_, fieldInfo]) => this.isDefaultAuthField(fieldInfo))
-                        .map(([field, fieldInfo]) => [field, this.getAuthSelector(fieldInfo)])
-                );
+                const defaultAuthSelectorFields: Record<string, { fieldType: string; selector: AuthContextSelector }> =
+                    Object.fromEntries(
+                        Object.entries(fields)
+                            .filter(([_, fieldInfo]) => this.isDefaultAuthField(fieldInfo))
+                            .map(([field, fieldInfo]) => [
+                                field,
+                                { fieldType: fieldInfo.type, selector: this.getAuthSelector(fieldInfo) },
+                            ])
+                    );
                 const defaultAuthFields = Object.fromEntries(
-                    Object.entries(defaultAuthSelectorFields).map(([field, authSelector]) => [
-                        field,
-                        deepGet(userContext, authSelector, userContext),
-                    ])
+                    Object.entries(defaultAuthSelectorFields).map(([field, { fieldType, selector }]) => {
+                        // if field type is String, we expect auth() to return the whole user context as string
+                        const defaultValue = fieldType === 'String' ? JSON.stringify(userContext) : userContext;
+                        return [field, deepGet(userContext, selector, defaultValue)];
+                    })
                 );
                 console.log('defaultAuthFields :', defaultAuthFields);
                 newArgs = { ...args, data: { ...defaultAuthFields, ...args.data } };

packages/sdk/src/model-meta-generator.ts

@@ -10,7 +10,7 @@ import {
     isStringLiteral,
     ReferenceExpr,
 } from '@zenstackhq/language/ast';
-import type { RuntimeAttribute } from '@zenstackhq/runtime';
+import type { AuthContextSelector, RuntimeAttribute } from '@zenstackhq/runtime';
 import { lowerCaseFirst } from 'lower-case-first';
 import { CodeBlockWriter, Project, VariableDeclarationKind } from 'ts-morph';
 import {
@@ -215,7 +215,7 @@ function getFieldAttributes(field: DataModelField): RuntimeAttribute[] {
                     attr.args[0].value.$cstNode?.text.startsWith('auth()')
                 ) {
                     const authValue = attr.args[0].value.$cstNode?.text;
-                    const authSelector = authValue === 'auth()' ? authValue : authValue.slice('auth().'.length);
+                    const authSelector: AuthContextSelector = authValue.slice('auth().'.length);
                     args.push({ name: 'auth()', value: authSelector });
                 } else {
                     // non-literal args are ignored

tests/integration/tests/enhancements/with-policy/auth.test.ts

@@ -416,6 +416,43 @@ describe('With Policy: auth() test', () => {
         await expect(userDb.post.count({ where: { authorName: overrideName } })).resolves.toBe(1);
     });
 
+    it('Default auth() return user context', async () => {
+        const { enhance, modelMeta } = await loadSchema(
+            `
+        model User {
+            id String @id
+            name String
+
+        }
+
+        model Post {
+            id String @id @default(uuid())
+            authorName String? @default(auth().name)
+            userDetailsAsString String? @default(auth())
+            userDetailsAsJson Json? @default(auth())
+
+            @@allow('all', true)
+        }
+        `,
+            {
+                provider: 'postgresql',
+                compile: true,
+            }
+        );
+
+        const userContext = { id: '1', name: 'user1' };
+        const db = enhance(userContext);
+        const userDetailsAttributes = modelMeta.fields.post.userDetails.attributes;
+        expect(userDetailsAttributes).toHaveProperty('0.name', '@default');
+        expect(userDetailsAttributes).toHaveProperty('0.args.0.name', 'auth()');
+        expect(userDetailsAttributes).toHaveProperty('0.args.0.value', '');
+        await expect(db.post.create({ data: {} })).toResolveTruthy();
+        await expect(db.post.count()).resolves.toBe(1);
+        const post = await db.post.findFirst();
+        expect(post?.userDetailsAsString).toEqual(JSON.stringify(userContext));
+        expect(post?.userDetailsAsJson).toEqual(userContext);
+    });
+
     it('Default auth() with foreign key', async () => {
         const { enhance, modelMeta } = await loadSchema(
             `