implement omit

Author: ymc9

TODO.md

@@ -8,7 +8,7 @@
     -   [x] info
     -   [ ] init
 -   [ ] ORM
-    -   [ ] Create
+    -   [x] Create
         -   [x] Input validation
         -   [x] Simple create
         -   [x] Nested create
@@ -18,7 +18,7 @@
     -   [ ] Find
         -   [x] Input validation
         -   [ ] Field selection
-            -   [ ] Omit
+            -   [x] Omit
             -   [x] Counting relation
         -   [x] Pagination
             -   [x] Skip and limit
@@ -50,6 +50,7 @@
     -   [ ] Extensions
         -   [x] Query builder API
         -   [x] Computed fields
+        -   [ ] Prisma client extension
     -   [ ] Misc
         -   [ ] Compound ID
         -   [ ] Cross field comparison

packages/runtime/src/client/client-types.ts

@@ -309,6 +309,9 @@ export type SelectInclude<
 > = {
     select?: Select<Schema, Model, AllowCount>;
     include?: Include<Schema, Model>;
+    omit?: {
+        [Key in ScalarFields<Schema, Model>]?: true;
+    };
 };
 
 type Select<
@@ -367,6 +370,8 @@ export type SelectSubset<T, U> = {
     [key in keyof T]: key extends keyof U ? T[key] : never;
 } & (T extends { select: any; include: any }
     ? 'Please either choose `select` or `include`.'
+    : T extends { select: any; omit: any }
+    ? 'Please either choose `select` or `omit`.'
     : {});
 
 type ToManyRelationFilter<

packages/runtime/src/client/crud/dialects/postgresql.ts

@@ -210,6 +210,13 @@ export class PostgresCrudDialect<
             objArgs.push(
                 ...Object.entries(relationModelDef.fields)
                     .filter(([, value]) => !value.relation)
+                    .filter(
+                        ([name]) =>
+                            !(
+                                typeof payload === 'object' &&
+                                (payload.omit as any)?.[name] === true
+                            )
+                    )
                     .map(([field]) => [
                         sql.lit(field),
                         buildFieldRef(

packages/runtime/src/client/crud/dialects/sqlite.ts

@@ -128,6 +128,13 @@ export class SqliteCrudDialect<
                 objArgs.push(
                     ...Object.entries(relationModelDef.fields)
                         .filter(([, value]) => !value.relation)
+                        .filter(
+                            ([name]) =>
+                                !(
+                                    typeof payload === 'object' &&
+                                    (payload.omit as any)?.[name] === true
+                                )
+                        )
                         .map(([field]) => [
                             sql.lit(field),
                             buildFieldRef(

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

@@ -138,7 +138,7 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
                 modelDef.dbTable
             );
         } else {
-            query = this.buildSelectAllScalarFields(model, query);
+            query = this.buildSelectAllScalarFields(model, query, args?.omit);
         }
 
         // include
@@ -308,12 +308,14 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
 
     private buildSelectAllScalarFields(
         model: string,
-        query: SelectQueryBuilder<any, any, {}>
+        query: SelectQueryBuilder<any, any, {}>,
+        omit?: Record<string, boolean | undefined>
     ) {
         let result = query;
         const modelDef = this.requireModel(model);
         return Object.keys(modelDef.fields)
             .filter((f) => !isRelationField(this.schema, model, f))
+            .filter((f) => omit?.[f] !== true)
             .reduce(
                 (acc, f) => this.selectField(acc, model, modelDef.dbTable, f),
                 result

packages/runtime/src/client/crud/operations/find.ts

@@ -33,10 +33,13 @@ export class FindOperationHandler<
                   operation === 'findUnique',
                   args
               )
-            : (args as FindArgs<Schema, GetModels<Schema>, true>);
+            : args;
 
         // run query
-        const result = await this.runQuery(this.model, parsedArgs);
+        const result = await this.runQuery(
+            this.model,
+            parsedArgs as FindArgs<Schema, GetModels<Schema>, true>
+        );
 
         const finalResult =
             operation === 'findMany' ? result : result[0] ?? null;

packages/runtime/src/client/crud/operations/validator.ts

@@ -28,37 +28,37 @@ export class InputValidator<Schema extends SchemaDef> {
 
     constructor(private readonly schema: Schema) {}
 
-    validateFindArgs(model: string, unique: boolean, args: unknown) {
+    validateFindArgs(model: GetModels<Schema>, unique: boolean, args: unknown) {
         return this.validate<FindArgs<Schema, GetModels<Schema>, true>>(
             this.makeFindSchema(model, unique, true),
             'find',
             args
         );
     }
 
-    validateCreateArgs(model: string, args: unknown) {
+    validateCreateArgs(model: GetModels<Schema>, args: unknown) {
         return this.validate<CreateArgs<Schema, GetModels<Schema>>>(
             this.makeCreateSchema(model),
             'create',
             args
         );
     }
 
-    validateCreateManyArgs(model: string, args: unknown) {
+    validateCreateManyArgs(model: GetModels<Schema>, args: unknown) {
         return this.validate<
             CreateManyArgs<Schema, GetModels<Schema>> | undefined
         >(this.makeCreateManySchema(model), 'createMany', args);
     }
 
-    validateUpdateArgs(model: string, args: unknown) {
+    validateUpdateArgs(model: GetModels<Schema>, args: unknown) {
         return this.validate<UpdateArgs<Schema, GetModels<Schema>>>(
             this.makeUpdateSchema(model),
             'update',
             args
         );
     }
 
-    validateUpdateManyArgs(model: string, args: unknown) {
+    validateUpdateManyArgs(model: GetModels<Schema>, args: unknown) {
         return this.validate<UpdateManyArgs<Schema, GetModels<Schema>>>(
             this.makeUpdateManySchema(model),
             'updateMany',
@@ -121,6 +121,7 @@ export class InputValidator<Schema extends SchemaDef> {
 
         fields['select'] = this.makeSelectSchema(model).optional();
         fields['include'] = this.makeIncludeSchema(model).optional();
+        fields['omit'] = this.makeOmitSchema(model).optional();
 
         if (collection) {
             fields['skip'] = z.number().int().nonnegative().optional();
@@ -133,6 +134,7 @@ export class InputValidator<Schema extends SchemaDef> {
 
         let result: ZodSchema = z.object(fields).strict();
         result = this.refineForSelectIncludeMutuallyExclusive(result);
+        result = this.refineForSelectOmitMutuallyExclusive(result);
 
         if (!unique) {
             result = result.optional();
@@ -446,6 +448,18 @@ export class InputValidator<Schema extends SchemaDef> {
         return z.object(fields).strict();
     }
 
+    protected makeOmitSchema(model: string) {
+        const modelDef = requireModel(this.schema, model);
+        const fields: Record<string, ZodSchema> = {};
+        for (const field of Object.keys(modelDef.fields)) {
+            const fieldDef = requireField(this.schema, model, field);
+            if (!fieldDef.relation) {
+                fields[field] = z.boolean().optional();
+            }
+        }
+        return z.object(fields).strict();
+    }
+
     protected makeIncludeSchema(model: string) {
         const modelDef = requireModel(this.schema, model);
         const fields: Record<string, ZodSchema> = {};
@@ -1029,6 +1043,13 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
+    private refineForSelectOmitMutuallyExclusive(schema: ZodSchema) {
+        return schema.refine(
+            (value) => !(value['select'] && value['omit']),
+            '"select" and "omit" cannot be used together'
+        );
+    }
+
     private nullableIf(schema: ZodSchema, nullable: boolean) {
         return nullable ? schema.nullable() : schema;
     }

packages/runtime/test/client-api/find.test.ts

@@ -489,6 +489,28 @@ describe.each(createClientSpecs(PG_DB_NAME))(
             });
         });
 
+        it('allows field omission', async () => {
+            const user = await createUser(client);
+            await createPosts(client, user.id);
+
+            const r = await client.user.findFirstOrThrow({
+                omit: { name: true },
+            });
+            expect('name' in r).toBeFalsy();
+            expect(r.email).toBeTruthy();
+
+            // @ts-expect-error omit and select cannot be used together
+            client.user.findFirstOrThrow({
+                omit: { name: true },
+                select: { email: true },
+            });
+
+            const r1 = await client.user.findFirstOrThrow({
+                include: { posts: { omit: { published: true } } },
+            });
+            expect('published' in r1.posts[0]!).toBeFalsy();
+        });
+
         it('allows including relation', async () => {
             const user = await createUser(client);
             const [post1, post2] = await createPosts(client, user.id);