fix(orm): exclude Unsupported fields from ORM client (#2468)

Author: ymc9

packages/clients/tanstack-query/src/common/types.ts

@@ -3,11 +3,12 @@ import type { FetchFn } from '@zenstackhq/client-helpers/fetch';
 import type {
     GetProcedureNames,
     GetSlicedOperations,
-    OperationsIneligibleForDelegateModels,
+    ModelAllowsCreate,
+    OperationsRequiringCreate,
     ProcedureFunc,
     QueryOptions,
 } from '@zenstackhq/orm';
-import type { GetModels, IsDelegateModel, SchemaDef } from '@zenstackhq/schema';
+import type { GetModels, SchemaDef } from '@zenstackhq/schema';
 
 /**
  * Context type for configuring the hooks.
@@ -59,8 +60,8 @@ export type ExtraMutationOptions = {
     optimisticDataProvider?: OptimisticDataProvider;
 } & QueryContext;
 
-type HooksOperationsIneligibleForDelegateModels = OperationsIneligibleForDelegateModels extends any
-    ? `use${Capitalize<OperationsIneligibleForDelegateModels>}`
+type HooksOperationsRequiringCreate = OperationsRequiringCreate extends any
+    ? `use${Capitalize<OperationsRequiringCreate>}`
     : never;
 
 type Modifiers = '' | 'Suspense' | 'Infinite' | 'SuspenseInfinite';
@@ -76,12 +77,12 @@ export type TrimSlicedOperations<
 > = {
     // trim operations based on slicing options
     [Key in keyof T as Key extends `use${Modifiers}${Capitalize<GetSlicedOperations<Schema, Model, Options>>}`
-        ? IsDelegateModel<Schema, Model> extends true
-            ? // trim operations ineligible for delegate models
-              Key extends HooksOperationsIneligibleForDelegateModels
-                ? never
-                : Key
-            : Key
+        ? ModelAllowsCreate<Schema, Model> extends true
+            ? Key
+            : // trim create operations for models that don't allow create
+              Key extends HooksOperationsRequiringCreate
+              ? never
+              : Key
         : never]: T[Key];
 };
 

packages/orm/src/client/client-impl.ts

@@ -48,6 +48,7 @@ type ExtResultFieldDef = {
 };
 import { getField } from './query-utils';
 import { createZenStackPromise, type ZenStackPromise } from './promise';
+import { fieldHasDefaultValue, isUnsupportedField, requireModel } from './query-utils';
 import { ResultProcessor } from './result-processor';
 
 /**
@@ -880,6 +881,14 @@ function createModelCrudHandler(
         }
     }
 
+    // Remove create/upsert operations for models with required Unsupported fields
+    const modelDef = requireModel(client.$schema, model);
+    if (Object.values(modelDef.fields).some((f) => isUnsupportedField(f) && !f.optional && !fieldHasDefaultValue(f))) {
+        for (const op of ['create', 'createMany', 'createManyAndReturn', 'upsert'] as const) {
+            delete (operations as any)[op];
+        }
+    }
+
     return operations as ModelOperations<any, any>;
 }
 

packages/orm/src/client/contract.ts

@@ -2,7 +2,6 @@ import {
     type FieldIsArray,
     type GetModels,
     type GetTypeDefs,
-    type IsDelegateModel,
     type ProcedureDef,
     type RelationFields,
     type RelationFieldType,
@@ -44,7 +43,12 @@ import type { ClientOptions, QueryOptions } from './options';
 import type { ExtClientMembersBase, ExtQueryArgsBase, ExtResultBase, RuntimePlugin } from './plugin';
 import type { ZenStackPromise } from './promise';
 import type { ToKysely } from './query-builder';
-import type { GetSlicedModels, GetSlicedOperations, GetSlicedProcedures } from './type-utils';
+import type {
+    GetSlicedModels,
+    GetSlicedOperations,
+    GetSlicedProcedures,
+    ModelAllowsCreate,
+} from './type-utils';
 import type { ZodSchemaFactory } from './zod/factory';
 
 type TransactionUnsupportedMethods = (typeof TRANSACTION_UNSUPPORTED_METHODS)[number];
@@ -292,8 +296,8 @@ type SliceOperations<
         // keep only operations included by slicing options
         [Key in keyof T as Key extends GetSlicedOperations<Schema, Model, Options> ? Key : never]: T[Key];
     },
-    // exclude operations not applicable to delegate models
-    IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never
+    // exclude create operations for models that don't allow create (delegate models, required Unsupported fields)
+    | (ModelAllowsCreate<Schema, Model> extends true ? never : OperationsRequiringCreate)
 >;
 
 export type AllModelOperations<
@@ -890,7 +894,7 @@ type CommonModelOperations<
     ): ZenStackPromise<Schema, boolean>;
 };
 
-export type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
+export type OperationsRequiringCreate = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
 
 export type ModelOperations<
     Schema extends SchemaDef,

packages/orm/src/client/crud-types.ts

@@ -6,7 +6,6 @@ import type {
     FieldHasDefault,
     FieldIsArray,
     FieldIsDelegateDiscriminator,
-    FieldIsDelegateRelation,
     FieldIsRelation,
     FieldType,
     ForeignKeyFields,
@@ -60,7 +59,7 @@ import type {
 import type { FilterKind, QueryOptions } from './options';
 import type { ExtQueryArgsBase, ExtResultBase } from './plugin';
 import type { ToKyselySchema } from './query-builder';
-import type { GetSlicedFilterKindsForField, GetSlicedModels } from './type-utils';
+import type { GetSlicedFilterKindsForField, GetSlicedModels, ModelAllowsCreate } from './type-utils';
 
 //#region Query results
 
@@ -1351,6 +1350,15 @@ type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>>
     }
 >;
 
+type RelationModelAllowsCreate<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Field extends RelationFields<Schema, Model>,
+> =
+    GetModelFieldType<Schema, Model, Field> extends GetModels<Schema>
+        ? ModelAllowsCreate<Schema, GetModelFieldType<Schema, Model, Field>>
+        : false;
+
 type CreateRelationFieldPayload<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
@@ -1380,8 +1388,8 @@ type CreateRelationFieldPayload<
     },
     // no "createMany" for non-array fields
     | (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany')
-    // exclude operations not applicable to delegate models
-    | (FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' : never)
+    // exclude create operations for models that don't allow create
+    | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate')
 >;
 
 type CreateRelationPayload<
@@ -1738,10 +1746,8 @@ type ToManyRelationUpdateInput<
          */
         set?: SetRelationInput<Schema, Model, Field, Options>;
     },
-    // exclude
-    FieldIsDelegateRelation<Schema, Model, Field> extends true
-        ? 'create' | 'createMany' | 'connectOrCreate' | 'upsert'
-        : never
+    // exclude create operations for models that don't allow create
+    | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate' | 'upsert')
 >;
 
 type ToOneRelationUpdateInput<
@@ -1788,7 +1794,8 @@ type ToOneRelationUpdateInput<
               delete?: NestedDeleteInput<Schema, Model, Field, Options>;
           }
         : {}),
-    FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never
+    // exclude create operations for models that don't allow create
+    | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'connectOrCreate' | 'upsert')
 >;
 
 // #endregion

packages/orm/src/client/crud/dialects/base-dialect.ts

@@ -26,9 +26,8 @@ import {
     getManyToManyRelation,
     getRelationForeignKeyFieldPairs,
     isEnum,
-    isInheritedField,
-    isRelationField,
     isTypeDef,
+    getModelFields,
     makeDefaultOrderBy,
     requireField,
     requireIdFields,
@@ -1127,33 +1126,26 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
         omit: Record<string, boolean | undefined> | undefined | null,
         modelAlias: string,
     ) {
-        const modelDef = requireModel(this.schema, model);
         let result = query;
 
-        for (const field of Object.keys(modelDef.fields)) {
-            if (isRelationField(this.schema, model, field)) {
-                continue;
-            }
-            if (this.shouldOmitField(omit, model, field)) {
+        for (const fieldDef of getModelFields(this.schema, model, { inherited: true, computed: true })) {
+            if (this.shouldOmitField(omit, model, fieldDef.name)) {
                 continue;
             }
-            result = this.buildSelectField(result, model, modelAlias, field);
+            result = this.buildSelectField(result, model, modelAlias, fieldDef.name);
         }
 
         // select all fields from delegate descendants and pack into a JSON field `$delegate$Model`
         const descendants = getDelegateDescendantModels(this.schema, model);
         for (const subModel of descendants) {
             result = this.buildDelegateJoin(model, modelAlias, subModel.name, result);
-            result = result.select((eb) => {
+            result = result.select(() => {
                 const jsonObject: Record<string, Expression<any>> = {};
-                for (const field of Object.keys(subModel.fields)) {
-                    if (
-                        isRelationField(this.schema, subModel.name, field) ||
-                        isInheritedField(this.schema, subModel.name, field)
-                    ) {
+                for (const fieldDef of getModelFields(this.schema, subModel.name, { computed: true })) {
+                    if (this.shouldOmitField(omit, subModel.name, fieldDef.name)) {
                         continue;
                     }
-                    jsonObject[field] = eb.ref(`${subModel.name}.${field}`);
+                    jsonObject[fieldDef.name] = this.fieldRef(subModel.name, fieldDef.name, subModel.name);
                 }
                 return this.buildJsonObject(jsonObject).as(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`);
             });

packages/orm/src/client/executor/name-mapper.ts

@@ -37,8 +37,8 @@ import {
     getEnum,
     getField,
     getModel,
+    getModelFields,
     isEnum,
-    requireModel,
     stripAlias,
 } from '../query-utils';
 
@@ -66,7 +66,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
                 this.modelToTableMap.set(modelName, mappedName);
             }
 
-            for (const fieldDef of this.getModelFields(modelDef)) {
+            for (const fieldDef of getModelFields(this.schema, modelName)) {
                 const mappedName = this.getMappedName(fieldDef);
                 if (mappedName) {
                     this.fieldToColumnMap.set(`${modelName}.${fieldDef.name}`, mappedName);
@@ -431,7 +431,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
                     if (!modelDef) {
                         continue;
                     }
-                    if (this.getModelFields(modelDef).some((f) => f.name === name)) {
+                    if (getModelFields(this.schema, scope.model).some((f) => f.name === name)) {
                         return scope;
                     }
                 }
@@ -560,8 +560,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
     }
 
     private createSelectAllFields(model: string, alias: OperationNode | undefined) {
-        const modelDef = requireModel(this.schema, model);
-        return this.getModelFields(modelDef).map((fieldDef) => {
+        return getModelFields(this.schema, model).map((fieldDef) => {
             const columnName = this.mapFieldName(model, fieldDef.name);
             const columnRef = ReferenceNode.create(
                 ColumnNode.create(columnName),
@@ -576,9 +575,6 @@ export class QueryNameMapper extends OperationNodeTransformer {
         });
     }
 
-    private getModelFields(modelDef: ModelDef) {
-        return Object.values(modelDef.fields).filter((f) => !f.relation && !f.computed && !f.originModel);
-    }
 
     private processSelections(selections: readonly SelectionNode[]) {
         const result: SelectionNode[] = [];
@@ -627,9 +623,8 @@ export class QueryNameMapper extends OperationNodeTransformer {
         }
 
         // expand select all to a list of selections with name mapping
-        const modelDef = requireModel(this.schema, scope.model);
-        return this.getModelFields(modelDef).map((fieldDef) => {
-            const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
+        return getModelFields(this.schema, scope.model).map((fieldDef) => {
+            const columnName = this.mapFieldName(scope.model!, fieldDef.name);
             const columnRef = ReferenceNode.create(ColumnNode.create(columnName));
 
             // process enum value mapping
@@ -660,7 +655,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
         if (!modelDef) {
             return false;
         }
-        return this.getModelFields(modelDef).some((fieldDef) => {
+        return getModelFields(this.schema, model).some((fieldDef) => {
             const enumDef = getEnum(this.schema, fieldDef.type);
             if (!enumDef) {
                 return false;

packages/orm/src/client/helpers/schema-db-pusher.ts

@@ -12,7 +12,7 @@ import {
     type SchemaDef,
 } from '../../schema';
 import type { ToKysely } from '../query-builder';
-import { requireModel } from '../query-utils';
+import { isUnsupportedField, requireModel } from '../query-utils';
 
 /**
  * This class is for testing purposes only. It should never be used in production.
@@ -117,6 +117,11 @@ export class SchemaDbPusher<Schema extends SchemaDef> {
                 continue;
             }
 
+            if (isUnsupportedField(fieldDef)) {
+                // Unsupported fields cannot be represented in the ORM's schema pusher
+                continue;
+            }
+
             if (fieldDef.relation) {
                 table = this.addForeignKeyConstraint(table, modelDef.name, fieldName, fieldDef);
             } else if (!this.isComputedField(fieldDef)) {

packages/orm/src/client/query-utils.ts

@@ -70,12 +70,12 @@ export function requireField(schema: SchemaDef, modelOrType: string, field: stri
 }
 
 /**
- * Gets all model fields, by default non-relation, non-computed, non-inherited fields only.
+ * Gets all model fields, by default non-relation, non-computed, non-inherited, non-unsupported fields only.
  */
 export function getModelFields(
     schema: SchemaDef,
     model: string,
-    options?: { relations?: boolean; computed?: boolean; inherited?: boolean },
+    options?: { relations?: boolean; computed?: boolean; inherited?: boolean; unsupported?: boolean },
 ) {
     const modelDef = requireModel(schema, model);
     return Object.values(modelDef.fields).filter((f) => {
@@ -88,10 +88,20 @@ export function getModelFields(
         if (f.originModel && !options?.inherited) {
             return false;
         }
+        if (f.type === 'Unsupported' && !options?.unsupported) {
+            return false;
+        }
         return true;
     });
 }
 
+/**
+ * Checks if a field is of `Unsupported` type.
+ */
+export function isUnsupportedField(fieldDef: FieldDef) {
+    return fieldDef.type === 'Unsupported';
+}
+
 export function getIdFields<Schema extends SchemaDef>(schema: SchemaDef, model: GetModels<Schema>) {
     const modelDef = getModel(schema, model);
     return modelDef?.idFields;

packages/orm/src/client/type-utils.ts

@@ -1,8 +1,39 @@
-import type { GetModels, SchemaDef } from '@zenstackhq/schema';
+import type { FieldDef, GetModel, GetModels, IsDelegateModel, SchemaDef } from '@zenstackhq/schema';
 import type { GetProcedureNames } from './crud-types';
 import type { AllCrudOperations } from './crud/operations/base';
 import type { FilterKind, QueryOptions, SlicingOptions } from './options';
 
+/**
+ * Checks if a model has any required Unsupported fields (non-optional, no default).
+ * Uses raw field access since `GetModelFields` excludes Unsupported fields.
+ */
+export type ModelHasRequiredUnsupportedField<Schema extends SchemaDef, Model extends GetModels<Schema>> = true extends {
+    [Key in Extract<keyof GetModel<Schema, Model>['fields'], string>]: GetModel<
+        Schema,
+        Model
+    >['fields'][Key] extends infer F extends FieldDef
+        ? F['type'] extends 'Unsupported'
+            ? F['optional'] extends true
+                ? false
+                : 'default' extends keyof F
+                  ? false
+                  : true
+            : false
+        : false;
+}[Extract<keyof GetModel<Schema, Model>['fields'], string>]
+    ? true
+    : false;
+
+/**
+ * Checks if a model allows create operations (not a delegate model and has no required Unsupported fields).
+ */
+export type ModelAllowsCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> =
+    IsDelegateModel<Schema, Model> extends true
+        ? false
+        : ModelHasRequiredUnsupportedField<Schema, Model> extends true
+          ? false
+          : true;
+
 type IsNever<T> = [T] extends [never] ? true : false;
 
 // #region Model slicing