@contember/schema-utils 2.1.0-alpha.3 → 2.1.0-alpha.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-utils",
-  "version": "2.1.0-alpha.3",
+  "version": "2.1.0-alpha.35",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -23,12 +23,17 @@
     }
   },
   "dependencies": {
-    "@contember/schema": "2.1.0-alpha.3",
-    "@contember/typesafe": "2.1.0-alpha.3"
+    "@contember/schema": "workspace:*",
+    "@contember/typesafe": "workspace:*"
   },
   "devDependencies": {
-    "@contember/schema-definition": "2.1.0-alpha.3",
-    "@types/node": "^20.17.22"
+    "@contember/schema-definition": "workspace:*",
+    "@types/node": "catalog:"
   },
-  "type": "module"
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/contember/contember.git",
+    "directory": "packages/schema-utils"
+  }
 }

package/src/acl/AllowAllPermissionFactory.ts

@@ -33,7 +33,7 @@ export class AllowAllPermissionFactory {
 					...(this.operations.includes(Acl.Operation.delete)
 						? {
 							delete: true,
-						  }
+						}
 						: {}),
 					...(allowCustomPrimary ? { customPrimary: true } : {}),
 				},

package/src/acl/PredicateDefinitionProcessor.ts

@@ -28,9 +28,7 @@ class PredicateDefinitionProcessor {
 					key,
 				])
 			} else if (key === 'and' || key === 'or') {
-				result[key] = (value as Acl.PredicateDefinition[]).map(it =>
-					this.processInternal(entity, it, handler, [...path, key]),
-				)
+				result[key] = (value as Acl.PredicateDefinition[]).map(it => this.processInternal(entity, it, handler, [...path, key]))
 			} else if (!entity.fields[key] && handler.handleUndefinedField) {
 				const undefinedResult = handler.handleUndefinedField({ entity, name: key, value, path })
 				if (undefinedResult !== undefined) {
@@ -57,10 +55,10 @@ class PredicateDefinitionProcessor {
 							path,
 						})
 						if (
-							typeof processedValue === 'object' &&
-							processedValue !== null &&
-							'constructor' in processedValue &&
-							processedValue.constructor.name === 'Object'
+							typeof processedValue === 'object'
+							&& processedValue !== null
+							&& 'constructor' in processedValue
+							&& processedValue.constructor.name === 'Object'
 						) {
 							return this.processInternal(
 								targetEntity,

package/src/dataUtils.ts

@@ -36,7 +36,7 @@ export const resolveDefaultValue = (column: Model.AnyColumn, providers: Pick<Pro
 		case Model.ColumnType.Uuid:
 			break
 		default:
-			((x: never) => {})(type)
+			;((x: never) => {})(type)
 	}
 
 	if (column.nullable) {

package/src/definition-generator/AclDefinitionCodeGenerator.ts

@@ -3,21 +3,21 @@ import { IndentDecider, Literal, printJsValue } from '../utils/printJsValue'
 import { Acl, Model, Schema } from '@contember/schema'
 import { DefinitionNamingConventions } from './DefinitionNamingConventions'
 
-
 const indentFirstLevel: IndentDecider = (val, path) => path.length === 0
 
 export class AclDefinitionCodeGenerator {
-
 	constructor(
 		private readonly definitionNamingConventions = new DefinitionNamingConventions(),
 	) {
 	}
 
 	public generateRoles({ acl }: { acl: Acl.Schema }): string {
-		return Object.entries(acl.roles).map(([name, values]) => this.generateRole({
-			name,
-			values,
-		})).join('')
+		return Object.entries(acl.roles).map(([name, values]) =>
+			this.generateRole({
+				name,
+				values,
+			})
+		).join('')
 	}
 
 	private generateRole({ name, values }: { name: string; values: Acl.RolePermissions }): string {
@@ -52,7 +52,7 @@ export class AclDefinitionCodeGenerator {
 		return variablesOutput.join('')
 	}
 
-	public generateEntityAcl({ entity, schema }: { entity: Model.Entity; schema: Schema  }): string {
+	public generateEntityAcl({ entity, schema }: { entity: Model.Entity; schema: Schema }): string {
 		const aclOutput: string[] = []
 		const numberOfEntityFieldsWithoutId = Object.keys(entity.fields).length - 1
 		for (const [roleName, roleDefinition] of Object.entries(schema.acl.roles)) {
@@ -110,7 +110,6 @@ export class AclDefinitionCodeGenerator {
 		for (const op of ['read', 'create', 'update'] as const) {
 			const fields = Object.entries(operations[op] ?? {}).filter(([, it]) => it === predicate).map(([it]) => it)
 			if (fields.length === 0) {
-				continue
 			} else if (fields.length === numberOfEntityFieldsWithoutId) {
 				result[op] = true
 			} else {

package/src/definition-generator/DefinitionCodeGenerator.ts

@@ -1,16 +1,9 @@
 import { Model, Schema, Writable } from '@contember/schema'
-import {
-	acceptFieldVisitor,
-	DefaultNamingConventions,
-	isInverseRelation,
-	NamingConventions,
-	resolveDefaultColumnType,
-} from '../model'
+import { acceptFieldVisitor, DefaultNamingConventions, isInverseRelation, NamingConventions, resolveDefaultColumnType } from '../model'
 import { printJsValue } from '../utils/printJsValue'
 import { DefinitionNamingConventions } from './DefinitionNamingConventions'
 import { AclDefinitionCodeGenerator } from './AclDefinitionCodeGenerator'
 
-
 export class DefinitionCodeGenerator {
 	constructor(
 		private readonly schemaNamingConventions: NamingConventions = new DefaultNamingConventions(),
@@ -57,7 +50,6 @@ ${Object.values(entity.fields).map(field => this.generateField({ field, entity,
 		return `@c.Index(${fieldsList})`
 	}
 
-
 	private generateView({ entity }: { entity: Model.Entity }): string | undefined {
 		if (!entity.view) {
 			return undefined
@@ -85,7 +77,6 @@ ${Object.values(entity.fields).map(field => this.generateField({ field, entity,
 				throw new Error(`Value ${providedValue} is not defined in enum ${enumName}`)
 			}
 			return `${enumName}.${enumValueKey}`
-
 		}
 		const formatOrderBy = (orderBy?: readonly Model.OrderBy[]) => {
 			return orderBy?.map(it => {
@@ -157,13 +148,18 @@ ${Object.values(entity.fields).map(field => this.generateField({ field, entity,
 				if (!relation.joiningTable.eventLog.enabled) {
 					joiningTable.eventLog = { enabled: false }
 				}
-				if (columnNames[0] !== relation.joiningTable.joiningColumn.columnName || relation.joiningTable.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+				if (
+					columnNames[0] !== relation.joiningTable.joiningColumn.columnName || relation.joiningTable.joiningColumn.onDelete !== Model.OnDelete.cascade
+				) {
 					joiningTable.joiningColumn = {
 						columnName: relation.joiningTable.joiningColumn.columnName,
 						onDelete: relation.joiningTable.joiningColumn.onDelete,
 					}
 				}
-				if (columnNames[1] !== relation.joiningTable.inverseJoiningColumn.columnName || relation.joiningTable.inverseJoiningColumn.onDelete !== Model.OnDelete.cascade) {
+				if (
+					columnNames[1] !== relation.joiningTable.inverseJoiningColumn.columnName
+					|| relation.joiningTable.inverseJoiningColumn.onDelete !== Model.OnDelete.cascade
+				) {
 					joiningTable.inverseJoiningColumn = {
 						columnName: relation.joiningTable.inverseJoiningColumn.columnName,
 						onDelete: relation.joiningTable.inverseJoiningColumn.onDelete,
@@ -215,7 +211,6 @@ ${Object.values(entity.fields).map(field => this.generateField({ field, entity,
 			parts.push(`typeAlias(${printJsValue(column.typeAlias)})`)
 		}
 
-
 		// todo: sequence
 		// todo: maybe single column unique()
 
@@ -227,7 +222,6 @@ ${Object.values(entity.fields).map(field => this.generateField({ field, entity,
 	}
 }
 
-
 const ColumnToMethodMapping: {
 	[K in Exclude<Model.ColumnType, Model.ColumnType.Enum>]: string
 } = {

package/src/definition-generator/DefinitionNamingConventions.ts

@@ -1,5 +1,54 @@
 export class DefinitionNamingConventions {
-	private static reservedWords = new Set(['do', 'if', 'in', 'for', 'let', 'new', 'try', 'var', 'case', 'else', 'enum', 'eval', 'null', 'this', 'true', 'void', 'with', 'await', 'break', 'catch', 'class', 'const', 'false', 'super', 'throw', 'while', 'yield', 'delete', 'export', 'import', 'public', 'return', 'static', 'switch', 'typeof', 'default', 'extends', 'finally', 'package', 'private', 'continue', 'debugger', 'function', 'arguments', 'interface', 'protected', 'implements', 'instanceof'])
+	private static reservedWords = new Set([
+		'do',
+		'if',
+		'in',
+		'for',
+		'let',
+		'new',
+		'try',
+		'var',
+		'case',
+		'else',
+		'enum',
+		'eval',
+		'null',
+		'this',
+		'true',
+		'void',
+		'with',
+		'await',
+		'break',
+		'catch',
+		'class',
+		'const',
+		'false',
+		'super',
+		'throw',
+		'while',
+		'yield',
+		'delete',
+		'export',
+		'import',
+		'public',
+		'return',
+		'static',
+		'switch',
+		'typeof',
+		'default',
+		'extends',
+		'finally',
+		'package',
+		'private',
+		'continue',
+		'debugger',
+		'function',
+		'arguments',
+		'interface',
+		'protected',
+		'implements',
+		'instanceof',
+	])
 
 	public formatIdentifier(id: string): string {
 		// todo: validate

package/src/index.ts

@@ -1,7 +1,7 @@
 import { Schema } from '@contember/schema'
 import { emptyModelSchema } from './model'
 import * as Typesafe from '@contember/typesafe'
-import { aclSchema, modelSchema, validationSchema, settingsSchema } from './type-schema'
+import { aclSchema, modelSchema, settingsSchema, validationSchema } from './type-schema'
 import { actionsSchema } from './type-schema/actions'
 
 export * from './definition-generator'
@@ -13,7 +13,7 @@ export * from './validation'
 export * from './schemaNormalizer'
 export * from './schemaFilter'
 export * from './schemaChecksum'
-export { deepCompare, compareArraysIgnoreOrder } from './utils'
+export { compareArraysIgnoreOrder, deepCompare } from './utils'
 
 export const emptySchema: Schema = {
 	model: emptyModelSchema,

package/src/lax/LaxSchemaConverter.ts

@@ -26,7 +26,6 @@ export class LaxSchemaConverter {
 		const builder = new LaxSchemaBuilder(this.schema, this.conventions)
 		return builder.build()
 	}
-
 }
 
 class LaxSchemaBuilder {
@@ -44,10 +43,8 @@ class LaxSchemaBuilder {
 			for (const [fieldName, fieldDefinition] of Object.entries(entityDefinition.fields)) {
 				if (isColumnDefinition(fieldDefinition)) {
 					this.processColumn(entityName, fieldName, fieldDefinition)
-
 				} else if (fieldDefinition.type === 'enum') {
 					this.processEnum(entityName, fieldName, fieldDefinition)
-
 				} else {
 					this.processRelation(entityName, fieldName, fieldDefinition)
 				}
@@ -188,7 +185,6 @@ class LaxSchemaBuilder {
 		;(entity.fields as Writable<Model.Entity['fields']>)[field.name] = field
 	}
 
-
 	private getEntity(entityName: string): Model.Entity {
 		return this.entities[entityName] ??= {
 			name: entityName,

package/src/lax/schema.ts

@@ -46,7 +46,10 @@ const LaxSchemaField = Typesafe.discriminatedUnion('type', {
 export type LaxSchemaField = ReturnType<typeof LaxSchemaField>
 export type LaxSchemaEnum = Extract<LaxSchemaField, { type: 'enum' }>
 export type LaxSchemaColumn = Extract<LaxSchemaField, { type: 'int' | 'float' | 'boolean' | 'string' | 'json' | 'datetime' | 'date' | 'uuid' }>
-export type LaxSchemaRelation = Extract<LaxSchemaField, {type: 'oneHasOne' | 'oneHasOneInverse' | 'manyHasMany' | 'manyHasManyInverse' | 'oneHasMany' | 'manyHasOne' }>
+export type LaxSchemaRelation = Extract<
+	LaxSchemaField,
+	{ type: 'oneHasOne' | 'oneHasOneInverse' | 'manyHasMany' | 'manyHasManyInverse' | 'oneHasMany' | 'manyHasOne' }
+>
 
 const LaxSchemaEntity = Typesafe.object({
 	fields: Typesafe.record(Typesafe.string, LaxSchemaField),

package/src/model/modelUtils.ts

@@ -14,8 +14,7 @@ export class ModelError extends Error {
 	}
 }
 
-const createEntityNotFoundError = (entityName: string) =>
-	new ModelError(ModelErrorCode.ENTITY_NOT_FOUND, `Entity ${entityName} not found`)
+const createEntityNotFoundError = (entityName: string) => new ModelError(ModelErrorCode.ENTITY_NOT_FOUND, `Entity ${entityName} not found`)
 
 const createFieldNotFoundError = (entityName: string, fieldName: string) =>
 	new ModelError(ModelErrorCode.FIELD_NOT_FOUND, `Field ${fieldName} of entity ${entityName} not found`)
@@ -184,8 +183,7 @@ export const acceptRelationTypeVisitor = <T>(
 					relation: relationObj,
 					targetEntity: targetEntity,
 					targetRelation: targetRelation as Model.ManyHasManyOwningRelation,
-				},
-				)
+				})
 			case Model.RelationType.OneHasOne:
 				return visitor.visitOneHasOneInverse({
 					type: 'oneHasOneInverse',

package/src/schemaChecksum.ts

@@ -1,7 +1,6 @@
 import { Schema } from '@contember/schema'
 import crypto from 'node:crypto'
 
-
 export const calculateSchemaChecksum = (schema: Schema): string => {
 	const jsonSchema = JSON.stringify(schema)
 

package/src/schemaFilter.ts

@@ -15,7 +15,7 @@ export const filterSchemaByStage = <S extends Schema>(schema: S, stageSlug: stri
 				...(definition.inherits
 					? {
 						inherits: definition.inherits.filter(it => roles.map(([role]) => role).includes(it)),
-					  }
+					}
 					: {}),
 			},
 		])

package/src/type-schema/acl.ts

@@ -2,19 +2,22 @@ import { Acl, Model } from '@contember/schema'
 import * as Typesafe from '@contember/typesafe'
 import { conditionSchema } from './condition'
 
-const membershipMatchRuleSchema = Typesafe.record(
-	Typesafe.string,
-	Typesafe.union(
-		Typesafe.literal(true),
-		Typesafe.partial({
-			variables: Typesafe.union(
-				Typesafe.literal(true),
-				Typesafe.record(
-					Typesafe.string,
-					Typesafe.union(Typesafe.literal(true), Typesafe.string),
+const membershipMatchRuleSchema = Typesafe.union(
+	Typesafe.boolean,
+	Typesafe.record(
+		Typesafe.string,
+		Typesafe.union(
+			Typesafe.literal(true),
+			Typesafe.partial({
+				variables: Typesafe.union(
+					Typesafe.literal(true),
+					Typesafe.record(
+						Typesafe.string,
+						Typesafe.union(Typesafe.literal(true), Typesafe.string),
+					),
 				),
-			),
-		}),
+			}),
+		),
 	),
 )
 

package/src/type-schema/actions.ts

@@ -45,12 +45,12 @@ const watchTriggerSchema = Typesafe.intersection(
 	Typesafe.partial({
 		selection: selectionNodeSchemaFactory(),
 		priority: Typesafe.integer,
+		withNodes: Typesafe.boolean,
 	}),
 )
 
 const watchTriggerSchemaCheck: Typesafe.Equals<Actions.WatchTrigger, ReturnType<typeof watchTriggerSchema>> = true
 
-
 const basicTriggerSchema = Typesafe.intersection(
 	Typesafe.object({
 		type: Typesafe.literal('basic'),
@@ -69,7 +69,6 @@ const basicTriggerSchema = Typesafe.intersection(
 
 const basicTriggerSchemaCheck: Typesafe.Equals<Actions.BasicTrigger, ReturnType<typeof basicTriggerSchema>> = true
 
-
 const anyTriggerSchema = Typesafe.union(
 	watchTriggerSchema,
 	basicTriggerSchema,

package/src/type-schema/condition.ts

@@ -25,24 +25,31 @@ const conditionSchemaInner = <T extends Json>(metadata: ResolvedColumnMetadata<T
 			isNull: Typesafe.boolean,
 			never: Typesafe.true_,
 			always: Typesafe.true_,
-			...(metadata.isJson !== true ? {
-				eq: inner,
-				notEq: inner,
-				in: Typesafe.array(inner),
-				notIn: Typesafe.array(inner),
-				lt: inner,
-				lte: inner,
-				gt: inner,
-				gte: inner,
-			} : {}),
-			...(metadata.isString !== false ? {
-				contains: Typesafe.string,
-				startsWith: Typesafe.string,
-				endsWith: Typesafe.string,
-				containsCI: Typesafe.string,
-				startsWithCI: Typesafe.string,
-				endsWithCI: Typesafe.string,
-			} : {}),
+			...(metadata.isJson !== true
+				? {
+					eq: inner,
+					notEq: inner,
+					in: Typesafe.array(inner),
+					notIn: Typesafe.array(inner),
+					lt: inner,
+					lte: inner,
+					gt: inner,
+					gte: inner,
+				}
+				: {
+					// For JSON columns, allow includes operator
+					includes: inner,
+				}),
+			...(metadata.isString !== false
+				? {
+					contains: Typesafe.string,
+					startsWith: Typesafe.string,
+					endsWith: Typesafe.string,
+					containsCI: Typesafe.string,
+					startsWithCI: Typesafe.string,
+					endsWithCI: Typesafe.string,
+				}
+				: {}),
 		}))
 		return objectSchema(input, path) as Input.Condition<T>
 	}
@@ -54,11 +61,9 @@ const resolveColumnMetadata = (type: Model.ColumnType): ResolvedColumnMetadata<a
 		type: resolvedType,
 		isJson: type === Model.ColumnType.Json,
 		isString: type === Model.ColumnType.String,
-
 	}
 }
 
-
 const resolveColumnTypeSchema = (type: Model.ColumnType) => {
 	switch (type) {
 		case Model.ColumnType.Bool:

package/src/type-schema/model.ts

@@ -52,7 +52,6 @@ const oneHasOneInverseRelationSchema = Typesafe.object({
 })
 const oneHasOneInverseRelationSchemaCheck: Typesafe.Equals<Model.OneHasOneInverseRelation, ReturnType<typeof oneHasOneInverseRelationSchema>> = true
 
-
 const oneHasOneOwningRelationSchema = Typesafe.intersection(
 	Typesafe.object({
 		type: Typesafe.literal(Model.RelationType.OneHasOne),
@@ -69,9 +68,12 @@ const oneHasOneOwningRelationSchema = Typesafe.intersection(
 
 const oneHasOneOwningRelationSchemaCheck: Typesafe.Equals<Model.OneHasOneOwningRelation, ReturnType<typeof oneHasOneOwningRelationSchema>> = true
 
-const eventLogSchema = Typesafe.coalesce(Typesafe.object({
-	enabled: Typesafe.boolean,
-}), { enabled: true }) as Typesafe.Type<{ readonly enabled: boolean }>
+const eventLogSchema = Typesafe.coalesce(
+	Typesafe.object({
+		enabled: Typesafe.boolean,
+	}),
+	{ enabled: true },
+) as Typesafe.Type<{ readonly enabled: boolean }>
 
 const manyHasManyOwningRelationSchema = Typesafe.intersection(
 	Typesafe.object({
@@ -90,7 +92,8 @@ const manyHasManyOwningRelationSchema = Typesafe.intersection(
 		orderBy: orderBySchema,
 	}),
 )
-const manyHasManyOwningRelationSchemaCheck: Typesafe.Equals<Model.ManyHasManyOwningRelation, ReturnType<typeof manyHasManyOwningRelationSchema>> = true
+const manyHasManyOwningRelationSchemaCheck: Typesafe.Equals<Model.ManyHasManyOwningRelation, ReturnType<typeof manyHasManyOwningRelationSchema>> =
+	true
 
 const manyHasManyInverseRelationSchema = Typesafe.intersection(
 	Typesafe.object({
@@ -103,7 +106,8 @@ const manyHasManyInverseRelationSchema = Typesafe.intersection(
 		orderBy: orderBySchema,
 	}),
 )
-const manyHasManyInverseRelationSchemaCheck: Typesafe.Equals<Model.ManyHasManyInverseRelation, ReturnType<typeof manyHasManyInverseRelationSchema>> = true
+const manyHasManyInverseRelationSchemaCheck: Typesafe.Equals<Model.ManyHasManyInverseRelation, ReturnType<typeof manyHasManyInverseRelationSchema>> =
+	true
 
 const intersectionSchema = Typesafe.intersection(
 	Typesafe.object({
@@ -162,13 +166,13 @@ const viewSchemaInner = Typesafe.intersection(
 const viewSchemaCheck: Typesafe.Equals<Model.View, ReturnType<typeof viewSchemaInner>> = true
 const viewSchema: Typesafe.Type<Model.View> = viewSchemaInner
 
-
 const indexSchemaBase = Typesafe.intersection(
 	Typesafe.object({
 		fields: Typesafe.array(Typesafe.string),
 	}),
 	Typesafe.partial({
 		name: Typesafe.string,
+		method: Typesafe.enumeration('btree', 'gin', 'gist', 'hash', 'brin', 'spgist'),
 	}),
 )
 const indexCheck: Typesafe.Equals<Model.Index, ReturnType<typeof indexSchemaBase>> = true
@@ -198,6 +202,7 @@ const uniqueIndex = Typesafe.intersection(
 	}),
 	Typesafe.partial({
 		nulls: Typesafe.enumeration('distinct', 'not distinct'),
+		method: Typesafe.enumeration('btree', 'gin', 'gist', 'hash', 'brin', 'spgist'),
 	}),
 )
 const uniqueConstraintCheck: Typesafe.Equals<Model.UniqueConstraint, ReturnType<typeof uniqueConstraint>> = true
@@ -229,4 +234,3 @@ export const modelSchema = Typesafe.object({
 	entities: Typesafe.record(Typesafe.string, entitySchema),
 	enums: Typesafe.record(Typesafe.string, Typesafe.array(Typesafe.string)),
 })
-

package/src/type-schema/validation.ts

@@ -9,10 +9,11 @@ const messageSchema = Typesafe.intersection(
 		parameters: Typesafe.array(Typesafe.union(Typesafe.string, Typesafe.number)),
 	}),
 )
-const literalArgumentFactory = <T extends Typesafe.Json>(inner: Typesafe.Type<T>) => Typesafe.object({
-	type: Typesafe.literal(Validation.ArgumentType.literal),
-	value: inner,
-})
+const literalArgumentFactory = <T extends Typesafe.Json>(inner: Typesafe.Type<T>) =>
+	Typesafe.object({
+		type: Typesafe.literal(Validation.ArgumentType.literal),
+		value: inner,
+	})
 
 const validatorArgumentSchema = Typesafe.object({
 	type: Typesafe.literal(Validation.ArgumentType.validator),

package/src/type-schema/where.ts

@@ -12,15 +12,17 @@ export const whereSchema = ({ schema, entity }: {
 			and: Typesafe.array(whereSchema({ schema, entity })),
 			or: Typesafe.array(whereSchema({ schema, entity })),
 			not: whereSchema({ schema, entity }),
-			...Object.fromEntries(Object.values(entity.fields).map((it): [string, Typesafe.Type<Input.Where[any]>] => {
-				return [
-					it.name,
-					acceptFieldVisitor(schema, entity, it.name, {
-						visitColumn: ({ column }) => conditionSchema(column.type),
-						visitRelation: ({ targetEntity }) => whereSchema({ schema, entity: targetEntity }),
-					}),
-				]
-			})),
+			...Object.fromEntries(
+				Object.values(entity.fields).map((it): [string, Typesafe.Type<Input.Where[any]>] => {
+					return [
+						it.name,
+						acceptFieldVisitor(schema, entity, it.name, {
+							visitColumn: ({ column }) => conditionSchema(column.type),
+							visitRelation: ({ targetEntity }) => whereSchema({ schema, entity: targetEntity }),
+						}),
+					]
+				}),
+			),
 		}))
 
 		return whereSchemaInner(input, path)

package/src/utils/deepCompare.ts

@@ -94,7 +94,7 @@ export function deepCompare(a: any, b: any, path: Path = [], getCustomComparator
 	if (aType === 'date') {
 		const aTime = a.getTime()
 		const bTime = b.getTime()
-		if (aTime == bTime) {
+		if (aTime === bTime) {
 			return []
 		}
 		return [