import SchemaBuilder, { BaseTypeRef, type EnumRef, type InputFieldMap, InputFieldRef, type InputObjectRef, type InputRef, type InputShapeFromTypeParam, type InputType, type InputTypeParam, PothosSchemaError, type SchemaTypes, } from '@pothos/core'; import { getModel, type PrismaModelTypes } from '@pothos/plugin-prisma'; import type { FilterListOps, FilterOps, FilterShape, IntFieldUpdateOperationsInput, OpsOptions, PrismaCreateManyRelationOptions, PrismaCreateOneRelationOptions, PrismaCreateOptions, PrismaFilterOptions, PrismaListFilterOptions, PrismaOrderByOptions, PrismaScalarListFilterOptions, PrismaUpdateManyRelationOptions, PrismaUpdateOneRelationOptions, PrismaUpdateOptions, PrismaWhereOptions, PrismaWhereUniqueOptions, ScalarListOps, } from './types.js'; export const schemaBuilder = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder; const OrderByRefMap = new WeakMap< PothosSchemaTypes.SchemaBuilder, EnumRef >(); const PrismaStringFilterModeRefMap = new WeakMap< PothosSchemaTypes.SchemaBuilder, EnumRef >(); const nullableOps = new Set(['equals', 'is', 'isNot', 'not']); schemaBuilder.prismaFilter = function prismaFilter< Type extends InputType, Ops extends OpsOptions, >(type: Type, { ops, name, ...options }: PrismaFilterOptions) { const filterName = name ?? `${nameFromType(type, this)}Filter`; const ref = this.inputRef< Pick< FilterShape>, Ops extends readonly string[] ? Ops[number] : keyof Ops > >(filterName); const opsOptions: Record = Array.isArray(ops) ? ((ops as string[]).reduce>((map, op) => { map[op] = {}; return map; }, {}) as {}) : ops; ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: { nullableFields: nullableOps }, }, fields: (t) => { const fields: InputFieldMap = {}; for (const op of Object.keys(opsOptions)) { const isList = op === 'in' || op === 'notIn'; let fieldType: InputType | [InputType]; switch (op) { case 'not': fieldType = ref; break; case 'in': case 'notIn': fieldType = [type]; break; case 'mode': fieldType = this.prismaStringFilterModeEnum(); break; default: fieldType = type; } fields[op] = t.field({ required: isList ? { list: false, items: true } : false, type: fieldType, ...(opsOptions[op] as {}), }); } return fields as never; }, }); return ref as never; }; schemaBuilder.prismaStringFilterModeEnum = function prismaStringFilterModeEnum() { if (PrismaStringFilterModeRefMap.has(this)) { return PrismaStringFilterModeRefMap.get(this)!; } const ref = this.enumType('StringFilterMode', { values: { Default: { value: 'default' as const }, Insensitive: { value: 'insensitive' as const }, }, }); PrismaStringFilterModeRefMap.set(this, ref); return ref; }; schemaBuilder.prismaListFilter = function prismaListFilter< Type extends InputType, Ops extends OpsOptions, >(type: Type, { name, ops, ...options }: PrismaListFilterOptions) { let filterName = name; if (!filterName) { const typeName = nameFromType(type, this); filterName = typeName.endsWith('Filter') ? typeName.replace(/Filter$/, 'ListFilter') : `List${typeName}`; } const ref = this.inputRef(filterName); const opsOptions: Record = Array.isArray(ops) ? ((ops as readonly string[]).reduce>((map, op) => { map[op] = {}; return map; }, {}) as {}) : ops; ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: true, }, fields: (t) => { const fields: InputFieldMap = {}; for (const op of Object.keys(opsOptions)) { fields[op] = t.field({ required: false, type, ...(opsOptions[op] as {}), }); } return fields as never; }, }); return ref as never; }; schemaBuilder.prismaScalarListFilter = function prismaScalarListFilter< Type extends InputType, Ops extends OpsOptions, >(type: Type, { name, ops, ...options }: PrismaScalarListFilterOptions) { let filterName = name; if (!filterName) { const typeName = nameFromType(type, this); filterName = `${typeName}ListFilter`; } const ref = this.inputRef(filterName); const opsOptions: Record = Array.isArray(ops) ? ((ops as readonly string[]).reduce>((map, op) => { map[op] = {}; return map; }, {}) as {}) : ops; ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: true, }, fields: (t) => { const fields: InputFieldMap = {}; for (const op of Object.keys(opsOptions)) { let fieldType: InputTypeParam = type; switch (op) { case 'has': fieldType = type; break; case 'equals': case 'hasSome': case 'hasEvery': fieldType = [type]; break; case 'isEmpty': fieldType = 'Boolean' as typeof fieldType; break; default: throw new Error(`Invalid op ${op} for scalar list filter`); } fields[op] = t.field({ required: false, type: fieldType, ...(opsOptions[op] as {}), }); } return fields as never; }, }); return ref as never; }; schemaBuilder.orderByEnum = function orderByEnum() { if (OrderByRefMap.has(this)) { return OrderByRefMap.get(this)!; } const ref = this.enumType('OrderBy', { values: { Asc: { value: 'asc' as const }, Desc: { value: 'desc' as const }, }, }); OrderByRefMap.set(this, ref); return ref; }; schemaBuilder.prismaOrderBy = function prismaOrderBy< Name extends keyof SchemaTypes['PrismaTypes'], Model extends PrismaModelTypes = SchemaTypes['PrismaTypes'][Name] extends PrismaModelTypes ? SchemaTypes['PrismaTypes'][Name] : never, >(type: Name, { name, fields, ...options }: PrismaOrderByOptions) { const filterName = name ?? `${nameFromType(type, this)}OrderBy`; const ref = this.inputRef>(filterName); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: true, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields() : fields; for (const [field, fieldOption] of Object.entries(fieldMap)) { if (typeof fieldOption === 'function') { const { type: fieldType, ...fieldOptions } = ( fieldOption as () => Partial> )(); fieldDefs[field] = t.field({ required: false, ...fieldOptions, type: fieldType ?? this.orderByEnum(), }); } else if (typeof fieldOption === 'boolean') { if (!fieldOption) { continue; } fieldDefs[field] = t.field({ required: false, type: this.orderByEnum(), }); } else { fieldDefs[field] = t.field({ required: false, type: fieldOption as InputRef, }); } } return fieldDefs as never; }, }); return ref as InputObjectRef; }; schemaBuilder.prismaWhere = function prismaWhere< Name extends keyof SchemaTypes['PrismaTypes'], Model extends PrismaModelTypes = SchemaTypes['PrismaTypes'][Name] extends PrismaModelTypes ? SchemaTypes['PrismaTypes'][Name] : never, Fields = {}, >( type: Name, { name, fields, ...options }: PrismaWhereOptions, ): InputObjectRef { const ref = this.inputRef(name ?? `${nameFromType(type, this)}Filter`); const model = getModel(type, this); const nullableFields = new Set( model.fields.filter((field) => !field.isRequired).map((field) => field.name), ); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: { nullableFields, }, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields(t) : fields; for (const [field, fieldOption] of Object.entries(fieldMap)) { if (!fieldOption) { continue; } if (field === 'AND' || field === 'OR' || field === 'NOT') { const fieldType = (fieldOption as unknown) === true ? ref : (fieldOption as InputRef); fieldDefs[field] = fieldOption instanceof InputFieldRef ? (fieldOption as InputFieldRef) : t.field({ required: false, type: field === 'NOT' ? fieldType : [fieldType], ...(typeof fieldOption === 'object' ? fieldOption : {}), }); continue; } fieldDefs[field] = fieldOption instanceof InputFieldRef ? fieldOption : t.field({ required: false, type: fieldOption as InputRef, }); } return fieldDefs as never; }, }); return ref; }; schemaBuilder.prismaWhereUnique = function prismaWhereUnique< Name extends keyof SchemaTypes['PrismaTypes'], Model extends PrismaModelTypes = SchemaTypes['PrismaTypes'][Name] extends PrismaModelTypes ? SchemaTypes['PrismaTypes'][Name] : never, Fields = {}, >( type: Name, { name, fields, ...options }: PrismaWhereUniqueOptions, ): InputObjectRef { const ref = this.inputRef(name ?? `${nameFromType(type, this)}UniqueFilter`); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: true, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields(t) : fields; for (const [field, fieldOption] of Object.entries(fieldMap)) { if (!fieldOption) { continue; } fieldDefs[field] = fieldOption instanceof InputFieldRef ? fieldOption : t.field({ required: false, type: fieldOption as InputRef, }); } return fieldDefs as never; }, }); return ref; }; schemaBuilder.prismaCreate = function prismaCreate< Name extends keyof SchemaTypes['PrismaTypes'], Model extends PrismaModelTypes = SchemaTypes['PrismaTypes'][Name] extends PrismaModelTypes ? SchemaTypes['PrismaTypes'][Name] : never, Fields = {}, >(type: Name, { name, fields, ...options }: PrismaCreateOptions) { const ref = this.inputRef(name ?? `${nameFromType(type, this)}CreateInput`); const model = getModel(type, this); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: { nullableFields: new Set( model.fields .filter( (field) => !field.isRequired && field.kind !== 'object' && field.type !== 'Json', ) .map((field) => field.name), ), }, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields(t) : fields; for (const field of Object.keys(fieldMap)) { const fieldModel = model.fields.find(({ name: fieldName }) => fieldName === field)!; const fieldOption = fieldMap[field as keyof typeof fieldMap]!; if (!fieldOption) { continue; } fieldDefs[field] = fieldOption instanceof InputFieldRef ? fieldOption : t.field({ required: fieldModel.isRequired && !fieldModel.isList && !fieldModel.hasDefaultValue && !fieldModel.isUpdatedAt, type: fieldModel.isList && fieldModel.kind !== 'object' ? [fieldOption as InputRef] : (fieldOption as InputRef), }); } return fieldDefs as never; }, }); return ref; }; schemaBuilder.prismaCreateMany = function prismaCreateMany( type: string, { name, fields, ...options }: PrismaCreateOptions, ) { const ref = this.inputRef(name ?? `${nameFromType(type as never, this)}CreateManyInput`); const model = getModel(type, this); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: { nullableFields: new Set( model.fields .filter( (field) => !field.isRequired && field.kind !== 'object' && field.type !== 'Json', ) .map((field) => field.name), ), }, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields(t) : fields; for (const field of Object.keys(fieldMap)) { const fieldModel = model.fields.find(({ name: fieldName }) => fieldName === field)!; const fieldOption = fieldMap[field as keyof typeof fieldMap]!; if (!fieldOption) { continue; } fieldDefs[field] = fieldOption instanceof InputFieldRef ? fieldOption : t.field({ required: fieldModel.isRequired && !fieldModel.isList && !fieldModel.hasDefaultValue && !fieldModel.isUpdatedAt, type: fieldModel.isList && fieldModel.kind !== 'object' ? [fieldOption as InputRef] : (fieldOption as InputRef), }); } return fieldDefs as never; }, }); return ref; }; schemaBuilder.prismaUpdate = function prismaUpdate< Name extends keyof SchemaTypes['PrismaTypes'], Model extends PrismaModelTypes = SchemaTypes['PrismaTypes'][Name] extends PrismaModelTypes ? SchemaTypes['PrismaTypes'][Name] : never, Fields = {}, >(type: Name, { name, fields, ...options }: PrismaUpdateOptions) { const ref = this.inputRef(name ?? `${nameFromType(type, this)}UpdateInput`); const model = getModel(type, this); const nullableFields = new Set( model.fields.filter((field) => !field.isRequired).map((field) => field.name), ); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: { nullableFields, }, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields(t) : fields; for (const field of Object.keys(fieldMap)) { const fieldModel = model.fields.find(({ name: fieldName }) => fieldName === field)!; const fieldOption = fieldMap[field as keyof typeof fieldMap]!; if (!fieldOption) { continue; } fieldDefs[field] = fieldOption instanceof InputFieldRef ? fieldOption : t.field({ required: false, type: fieldModel.isList && fieldModel.kind !== 'object' ? [fieldOption as InputRef] : (fieldOption as InputRef), }); } return fieldDefs as never; }, }); return ref; }; schemaBuilder.prismaCreateRelation = function prismaCreateRelation< Name extends keyof SchemaTypes['PrismaTypes'], Relation extends Model['RelationName'], Model extends PrismaModelTypes = SchemaTypes['PrismaTypes'][Name] extends PrismaModelTypes ? SchemaTypes['PrismaTypes'][Name] : never, >( type: Name, relation: Relation, { name, fields, ...options }: Relation extends Model['ListRelations'] ? PrismaCreateManyRelationOptions : PrismaCreateOneRelationOptions, ) { const ref = this.inputRef( name ?? `${nameFromType(type, this)}Create${capitalize(relation)}RelationInput`, ); const model = getModel(type, this); const fieldModel = model.fields.find((field) => field.name === relation)!; ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: true, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields(t) : fields; for (const [field, fieldOption] of Object.entries(fieldMap)) { if (!fieldOption) { continue; } fieldDefs[field] = fieldOption instanceof InputFieldRef ? fieldOption : t.field({ required: false, type: fieldModel.isList ? [fieldOption as InputRef] : (fieldOption as InputRef), }); } return fieldDefs as never; }, }); return ref as never; }; schemaBuilder.prismaUpdateRelation = function prismaUpdateRelation< Name extends keyof SchemaTypes['PrismaTypes'], Relation extends Model['RelationName'], Model extends PrismaModelTypes = SchemaTypes['PrismaTypes'][Name] extends PrismaModelTypes ? SchemaTypes['PrismaTypes'][Name] : never, >( type: Name, relation: Relation, { name, fields, ...options }: Relation extends Model['ListRelations'] ? PrismaUpdateManyRelationOptions : PrismaUpdateOneRelationOptions, ) { const ref = this.inputRef( name ?? `${nameFromType(type, this)}Update${capitalize(relation)}RelationInput`, ); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: true, }, fields: (t) => { const fieldDefs: InputFieldMap = {}; const fieldMap = typeof fields === 'function' ? fields(t) : fields; const model = getModel(type, this); const fieldModel = model.fields.find((field) => field.name === relation)!; for (const [field, fieldOption] of Object.entries(fieldMap)) { if (!fieldOption) { continue; } if (fieldOption instanceof InputFieldRef) { fieldDefs[field] = fieldOption; } else if (fieldModel.isList && (field === 'update' || field === 'updateMany')) { const { name: nestedName = `${ref.name}U${field.slice(1)}`, where: whereType, data: dataType, } = fieldOption as { name?: string; where: InputFieldRef | InputRef; data: InputFieldRef | InputRef; }; const nestedRef = this.inputType(nestedName, { fields: (t2) => ({ where: whereType instanceof InputFieldRef ? whereType : t2.field({ type: whereType }), data: dataType instanceof InputFieldRef ? dataType : t2.field({ type: dataType }), }), }); fieldDefs[field] = t.field({ required: false, type: [nestedRef], }); } else if (fieldModel.isList && field === 'createMany') { const { name: nestedName = `${ref.name}CreateMany`, data: dataType, skipDuplicates, } = fieldOption as { name?: string; data: InputFieldRef | InputRef; skipDuplicates?: InputFieldRef | InputRef; }; const nestedRef = this.inputType(nestedName, { fields: (t2) => ({ ...(skipDuplicates ? { skipDuplicates: skipDuplicates instanceof InputFieldRef ? skipDuplicates : t2.field({ type: skipDuplicates }), } : {}), data: dataType instanceof InputFieldRef ? dataType : t2.field({ type: [dataType] }), }), }); fieldDefs[field] = t.field({ required: false, type: nestedRef, }); } else if ((field === 'disconnect' || field === 'delete') && fieldOption === true) { fieldDefs[field] = t.field({ required: false, type: 'Boolean', }); } else { fieldDefs[field] = t.field({ required: false, type: fieldModel.isList ? [fieldOption as InputRef] : (fieldOption as InputRef), }); } } return fieldDefs as never; }, }); return ref as never; }; function nameFromType( type: InputType, builder: PothosSchemaTypes.SchemaBuilder, ) { if (typeof type === 'string') { return type; } if (builder.configStore.hasConfig(type)) { return builder.configStore.getTypeConfig(type).name; } if (typeof type === 'function' && 'name' in type) { return (type as { name: string }).name; } if (type instanceof BaseTypeRef) { return type.name; } throw new PothosSchemaError(`Unable to determine name for type ${String(type)}`); } schemaBuilder.prismaIntAtomicUpdate = function prismaIntUpdateOperations({ name, ops = ['set', 'increment', 'decrement', 'multiply', 'divide'], ...options } = {}) { const ref = this.inputRef(name ?? 'IntAtomicUpdate'); ref.implement({ ...options, extensions: { ...options.extensions, pothosPrismaInput: true, }, fields: (t) => { const fieldDefs: Record> = {}; for (const op of ops) { fieldDefs[op] = t.field({ required: false, type: 'Int', }); } return fieldDefs; }, }); return ref as never; }; function capitalize(str: string) { return str[0].toUpperCase() + str.slice(1); }