@contember/schema-definition 2.1.0-beta.2 → 2.2.0-alpha.2

package/src/model/definition/OrderByDefinition.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
-import { extendEntity } from './extensions'
-import { DecoratorFunction } from '../../utils'
+import { extendEntity } from './extensions.js'
+import { DecoratorFunction } from '../../utils/index.js'
 
 export type OrderByDirection = Model.OrderDirection | `${Model.OrderDirection}`
 export type OrderByOptions = { path: string[]; direction?: OrderByDirection }

package/src/model/definition/UniqueDefinition.ts

@@ -1,5 +1,5 @@
-import { extendEntity } from './extensions'
-import { DecoratorFunction } from '../../utils'
+import { extendEntity } from './extensions.js'
+import { DecoratorFunction } from '../../utils/index.js'
 import { Model } from '@contember/schema'
 
 export type UniqueOptions<T> =

package/src/model/definition/ViewDefinition.ts

@@ -1,6 +1,6 @@
-import { extendEntity } from './extensions'
-import { EntityConstructor } from './types'
-import { DecoratorFunction } from '../../utils'
+import { extendEntity } from './extensions.js'
+import { EntityConstructor } from './types.js'
+import { DecoratorFunction } from '../../utils/index.js'
 
 export type ViewOptions<T> = {
 	dependencies?: (() => EntityConstructor[]) | EntityConstructor[]

package/src/model/definition/context.ts

@@ -1,5 +1,5 @@
-import { EntityRegistry, EnumRegistry } from './internal'
-import { StrictDefinitionValidator } from '../../strict'
+import { EntityRegistry, EnumRegistry } from './internal/index.js'
+import { StrictDefinitionValidator } from '../../strict.js'
 import { NamingConventions } from '@contember/schema-utils'
 
 export type CommonContext = {

package/src/model/definition/extensions.ts

@@ -1,8 +1,8 @@
 import { Model } from '@contember/schema'
-import { EntityConstructor, FieldsDefinition } from './types'
-import { EntityRegistry } from './internal'
-import { createMetadataStore, DecoratorFunction } from '../../utils'
-import { CommonContext } from './context'
+import { EntityConstructor, FieldsDefinition } from './types.js'
+import { EntityRegistry } from './internal/index.js'
+import { createMetadataStore, DecoratorFunction } from '../../utils/index.js'
+import { CommonContext } from './context.js'
 
 export type EntityExtensionArgs =
 	& {

package/src/model/definition/fieldDefinitions/ColumnDefinition.ts

@@ -1,6 +1,6 @@
-import { Model } from '@contember/schema'
-import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
-import { EnumDefinition } from '../EnumDefinition'
+import { JSONValue, Model } from '@contember/schema'
+import { CreateFieldContext, FieldDefinition } from './FieldDefinition.js'
+import { EnumDefinition } from '../EnumDefinition.js'
 import { resolveDefaultColumnType } from '@contember/schema-utils'
 
 export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
@@ -59,6 +59,19 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 		return this.withOption('collation', collation)
 	}
 
+	/**
+	 * Attaches a JSON Schema to a JSON column. Input values are validated against it on create/update.
+	 * The schema is stored as metadata and does not affect the database schema.
+	 *
+	 * Only honored for JSON columns ({@link jsonColumn}); it is silently ignored on other column types.
+	 * Validation runs on mutation input only — stored rows are not re-validated when the schema changes,
+	 * and the data-transfer/import path bypasses it. Only a subset of JSON Schema keywords is supported;
+	 * see {@link validateJsonSchema} for the exact list.
+	 */
+	public schema(schema: JSONValue): ColumnDefinition {
+		return this.withOption('schema', schema)
+	}
+
 	createField({ name, conventions, enumRegistry, entityName, options }: CreateFieldContext): Model.AnyField {
 		const {
 			type,
@@ -71,6 +84,7 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 			sequence,
 			list,
 			collation = options.defaultCollation,
+			schema,
 		} = this.options
 		const common = {
 			name: name,
@@ -80,6 +94,7 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 			...(defaultValue !== undefined ? { default: defaultValue } : {}),
 			...(sequence !== undefined ? { sequence } : {}),
 			...(type === Model.ColumnType.String && collation !== undefined ? { collation } : {}),
+			...(type === Model.ColumnType.Json && schema !== undefined ? { schema } : {}),
 		}
 		if (type === Model.ColumnType.Enum) {
 			if (typeAlias) {
@@ -131,6 +146,21 @@ export function doubleColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Double)
 }
 
+/**
+ * Creates a `numeric(precision, scale)` (a.k.a. `decimal`) column.
+ *
+ * Values are transported over GraphQL as strings (e.g. `'-123456789123.456'`) to avoid
+ * JavaScript floating-point precision loss. The value returned by the API is the exact
+ * Postgres `numeric` text representation, which includes trailing zeros up to the column
+ * scale (e.g. `123.450000000` for `numeric(20, 9)`).
+ *
+ * @param precision total number of significant digits
+ * @param scale number of digits after the decimal point
+ */
+export function numericColumn(precision: number, scale: number): ColumnDefinition {
+	return column(Model.ColumnType.Numeric).columnType(`${resolveDefaultColumnType(Model.ColumnType.Numeric)}(${precision}, ${scale})`)
+}
+
 export function dateColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Date)
 }
@@ -173,4 +203,5 @@ export type ColumnDefinitionOptions = {
 	default?: Model.ColumnTypeDefinition['default']
 	sequence?: Model.ColumnTypeDefinition['sequence']
 	collation?: Model.Collation
+	schema?: JSONValue
 } & ColumnTypeOptions

package/src/model/definition/fieldDefinitions/FieldDefinition.ts

@@ -1,5 +1,5 @@
 import { Model } from '@contember/schema'
-import { CommonContext } from '../context'
+import { CommonContext } from '../context.js'
 
 export abstract class FieldDefinition<O> {
 	constructor(public readonly options: O) {

package/src/model/definition/fieldDefinitions/ManyHasManyDefinition.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
-import { EntityConstructor, RelationTarget } from '../types'
-import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
+import { EntityConstructor, RelationTarget } from '../types.js'
+import { CreateFieldContext, FieldDefinition } from './FieldDefinition.js'
 
 export class ManyHasManyDefinition extends FieldDefinition<ManyHasManyDefinitionOptions> {
 	type = 'ManyHasManyDefinition' as const

package/src/model/definition/fieldDefinitions/ManyHasManyInverseDefinition.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
-import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
-import { EntityConstructor, RelationTarget } from '../types'
+import { CreateFieldContext, FieldDefinition } from './FieldDefinition.js'
+import { EntityConstructor, RelationTarget } from '../types.js'
 
 export class ManyHasManyInverseDefinition extends FieldDefinition<ManyHasManyInverseDefinitionOptions> {
 	type = 'ManyHasManyInverseDefinition' as const

package/src/model/definition/fieldDefinitions/ManyHasOneDefinition.ts

@@ -1,6 +1,6 @@
-import { EntityConstructor, RelationTarget } from '../types'
+import { EntityConstructor, RelationTarget } from '../types.js'
 import { Model } from '@contember/schema'
-import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
+import { CreateFieldContext, FieldDefinition } from './FieldDefinition.js'
 
 export class ManyHasOneDefinition extends FieldDefinition<ManyHasOneDefinitionOptions> {
 	type = 'ManyHasOneDefinition' as const

package/src/model/definition/fieldDefinitions/OneHasManyDefinition.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
-import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
-import { EntityConstructor, RelationTarget } from '../types'
+import { CreateFieldContext, FieldDefinition } from './FieldDefinition.js'
+import { EntityConstructor, RelationTarget } from '../types.js'
 
 export class OneHasManyDefinition extends FieldDefinition<OneHasManyDefinitionOptions> {
 	type = 'OneHasManyDefinition' as const

package/src/model/definition/fieldDefinitions/OneHasOneDefinition.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
-import { EntityConstructor, RelationTarget } from '../types'
-import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
+import { EntityConstructor, RelationTarget } from '../types.js'
+import { CreateFieldContext, FieldDefinition } from './FieldDefinition.js'
 
 export class OneHasOneDefinition extends FieldDefinition<OneHasOneDefinitionOptions> {
 	type = 'OneHasOneDefinition' as const

package/src/model/definition/fieldDefinitions/OneHasOneInverseDefinition.ts

@@ -1,7 +1,7 @@
 import { Model } from '@contember/schema'
-import { EntityConstructor } from '../types'
-import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
-import { RelationTarget } from '../types'
+import { EntityConstructor } from '../types.js'
+import { CreateFieldContext, FieldDefinition } from './FieldDefinition.js'
+import { RelationTarget } from '../types.js'
 
 export class OneHasOneInverseDefinition extends FieldDefinition<OneHasOneInverseDefinitionOptions> {
 	type = 'OneHasOneInverseDefinition' as const

package/src/model/definition/fieldDefinitions/index.ts

@@ -1,8 +1,8 @@
-export * from './ColumnDefinition'
-export * from './FieldDefinition'
-export * from './ManyHasManyDefinition'
-export * from './ManyHasManyInverseDefinition'
-export * from './ManyHasOneDefinition'
-export * from './OneHasManyDefinition'
-export * from './OneHasOneDefinition'
-export * from './OneHasOneInverseDefinition'
+export * from './ColumnDefinition.js'
+export * from './FieldDefinition.js'
+export * from './ManyHasManyDefinition.js'
+export * from './ManyHasManyInverseDefinition.js'
+export * from './ManyHasOneDefinition.js'
+export * from './OneHasManyDefinition.js'
+export * from './OneHasOneDefinition.js'
+export * from './OneHasOneInverseDefinition.js'

package/src/model/definition/index.ts

@@ -1,20 +1,20 @@
 import { Model } from '@contember/schema'
-import { EnumDefinition } from './EnumDefinition'
-import { SchemaBuilder } from './internal'
+import { EnumDefinition } from './EnumDefinition.js'
+import { SchemaBuilder } from './internal/index.js'
 import 'reflect-metadata'
-import { FieldDefinition } from './fieldDefinitions'
-import { isEntityConstructor } from '../../utils'
+import { FieldDefinition } from './fieldDefinitions/index.js'
+import { isEntityConstructor } from '../../utils/index.js'
 import { DefaultNamingConventions } from '@contember/schema-utils'
-import { StrictDefinitionValidator, StrictOptions } from '../../strict'
+import { StrictDefinitionValidator, StrictOptions } from '../../strict.js'
 
-export * from './fieldDefinitions'
-export * from './EventLogDefinition'
-export * from './IndexDefinition'
-export * from './OrderByDefinition'
-export * from './EnumDefinition'
-export * from './UniqueDefinition'
-export * from './ViewDefinition'
-export { type EntityExtension, extendEntity } from './extensions'
+export * from './fieldDefinitions/index.js'
+export * from './EventLogDefinition.js'
+export * from './IndexDefinition.js'
+export * from './OrderByDefinition.js'
+export * from './EnumDefinition.js'
+export * from './UniqueDefinition.js'
+export * from './ViewDefinition.js'
+export { type EntityExtension, extendEntity } from './extensions.js'
 
 export abstract class Entity {
 	[key: string]: FieldDefinition<any> | undefined

package/src/model/definition/internal/EntityRegistry.ts

@@ -1,4 +1,4 @@
-import { EntityConstructor } from '../../../utils'
+import { EntityConstructor } from '../../../utils/index.js'
 
 export class EntityRegistry {
 	public readonly entities: Record<string, EntityConstructor> = {}

package/src/model/definition/internal/EnumRegistry.ts

@@ -1,4 +1,4 @@
-import { EnumDefinition } from '../EnumDefinition'
+import { EnumDefinition } from '../EnumDefinition.js'
 
 export class EnumRegistry {
 	public readonly enums: Record<string, EnumDefinition> = {}

package/src/model/definition/internal/SchemaBuilder.ts

@@ -1,14 +1,14 @@
 import { Model } from '@contember/schema'
 import { NamingConventions } from '@contember/schema-utils'
 import 'reflect-metadata'
-import { tuple } from '../../../utils'
-import { EntityConstructor, FieldsDefinition } from '../types'
-import { EnumDefinition } from '../EnumDefinition'
-import { EntityRegistry } from './EntityRegistry'
-import { EnumRegistry } from './EnumRegistry'
-import { ColumnDefinition } from '../fieldDefinitions'
-import { applyEntityExtensions } from '../extensions'
-import { StrictDefinitionValidator, StrictOptions } from '../../../strict'
+import { tuple } from '../../../utils/index.js'
+import { EntityConstructor, FieldsDefinition } from '../types.js'
+import { EnumDefinition } from '../EnumDefinition.js'
+import { EntityRegistry } from './EntityRegistry.js'
+import { EnumRegistry } from './EnumRegistry.js'
+import { ColumnDefinition } from '../fieldDefinitions/index.js'
+import { applyEntityExtensions } from '../extensions.js'
+import { StrictDefinitionValidator, StrictOptions } from '../../../strict.js'
 
 export class SchemaBuilder {
 	private entityRegistry = new EntityRegistry()

package/src/model/definition/internal/index.ts

@@ -1,3 +1,3 @@
-export * from './EntityRegistry'
-export * from './EnumRegistry'
-export * from './SchemaBuilder'
+export * from './EntityRegistry.js'
+export * from './EnumRegistry.js'
+export * from './SchemaBuilder.js'

package/src/model/definition/types.ts

@@ -1,5 +1,5 @@
-import { EntityConstructor } from '../../utils'
-import { FieldDefinition } from './fieldDefinitions'
+import { EntityConstructor } from '../../utils/index.js'
+import { FieldDefinition } from './fieldDefinitions/index.js'
 
 export type RelationTarget = EntityConstructor
 export type FieldsDefinition = Record<string, FieldDefinition<any>>

package/src/model/index.ts

@@ -1,10 +1,10 @@
-import SchemaBuilder from './builder/SchemaBuilder'
-import ColumnBuilder from './builder/ColumnBuilder'
-import ManyHasManyBuilder from './builder/ManyHasManyBuilder'
-import OneHasManyBuilder from './builder/OneHasManyBuilder'
-import ManyHasOneBuilder from './builder/ManyHasOneBuilder'
-import OneHasOneBuilder from './builder/OneHasOneBuilder'
-import FieldBuilder from './builder/FieldBuilder'
-import * as SchemaDefinition from './definition'
+import SchemaBuilder from './builder/SchemaBuilder.js'
+import ColumnBuilder from './builder/ColumnBuilder.js'
+import ManyHasManyBuilder from './builder/ManyHasManyBuilder.js'
+import OneHasManyBuilder from './builder/OneHasManyBuilder.js'
+import ManyHasOneBuilder from './builder/ManyHasOneBuilder.js'
+import OneHasOneBuilder from './builder/OneHasOneBuilder.js'
+import FieldBuilder from './builder/FieldBuilder.js'
+import * as SchemaDefinition from './definition/index.js'
 
 export { ColumnBuilder, FieldBuilder, ManyHasManyBuilder, ManyHasOneBuilder, OneHasManyBuilder, OneHasOneBuilder, SchemaBuilder, SchemaDefinition }

package/src/strict.ts

@@ -12,9 +12,17 @@ export const allStrict: StrictOptions = {
 
 export type Warning = { message: string }
 
+type OnDeleteValidation = {
+	entityName: string
+	field: string
+	hasOnDelete: boolean
+}
+
 export class StrictDefinitionValidator {
 	public readonly warnings: Warning[] = []
 
+	private readonly onDeleteValidations: OnDeleteValidation[] = []
+
 	constructor(
 		private readonly options: StrictOptions,
 	) {
@@ -27,10 +35,27 @@ export class StrictDefinitionValidator {
 	}
 
 	public validateOnCascade(entityName: string, field: string, definition: { onDelete?: Model.OnDelete }): void {
-		if (!definition.onDelete && this.options.requireOnDelete) {
-			this.registerWarning(
-				`${entityName}.${field}: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`,
-			)
+		// View entities are read-only and have no real delete semantics, so onDelete validation is
+		// deferred to validateModel() where we know which entities are views.
+		this.onDeleteValidations.push({ entityName, field, hasOnDelete: definition.onDelete !== undefined })
+	}
+
+	public validateModel(model: Model.Schema): void {
+		for (const { entityName, field, hasOnDelete } of this.onDeleteValidations) {
+			const isView = model.entities[entityName]?.view !== undefined
+			if (isView) {
+				if (hasOnDelete) {
+					this.registerWarning(
+						`${entityName}.${field}: onDelete behaviour must not be set on a relation of a view entity. Views are read-only and have no delete semantics.`,
+					)
+				}
+				continue
+			}
+			if (!hasOnDelete && this.options.requireOnDelete) {
+				this.registerWarning(
+					`${entityName}.${field}: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`,
+				)
+			}
 		}
 	}
 

package/src/utils/filterEntityDefinition.ts

@@ -1,4 +1,4 @@
-import { EntityConstructor } from './decorators'
+import { EntityConstructor } from './decorators.js'
 
 export const filterEntityDefinition = (definitions: Record<string, unknown>): [string, EntityConstructor][] =>
 	Object.entries(definitions)

package/src/utils/index.ts

@@ -1,5 +1,5 @@
-export * from './assertNever'
-export * from './filterEntityDefinition'
-export * from './tuple'
-export * from './decorators'
-export * from './MetadataStore'
+export * from './assertNever.js'
+export * from './filterEntityDefinition.js'
+export * from './tuple.js'
+export * from './decorators.js'
+export * from './MetadataStore.js'

package/src/validation/index.ts

@@ -1,7 +1,7 @@
-import { tuple } from '../utils'
-import { SchemaDefinition } from '../model'
+import { tuple } from '../utils/index.js'
+import { SchemaDefinition } from '../model/index.js'
 import { Validation } from '@contember/schema'
-import { filterEntityDefinition } from '../utils'
+import { filterEntityDefinition } from '../utils/index.js'
 
 type MessageOrString = Validation.Message | string
 

package/tests/cases/unit/createSchema.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test'
-import { c, createSchema, settingsPresets } from '../../../src'
+import { c, createSchema, settingsPresets } from '../../../src/index.js'
 
 namespace SimpleModel {
 	export const publicRole = c.createRole('public')
@@ -96,6 +96,48 @@ test('basic createSchema test', () => {
 	})
 })
 
+namespace IndexModel {
+	@c.Index('title')
+	@c.Index({ fields: ['title'], where: 'title IS NOT NULL' })
+	@c.Index({ fields: ['title'], include: ['content'] })
+	@c.Index({ fields: ['title'], include: ['content'], where: 'published', method: 'btree' })
+	export class Article {
+		title = c.stringColumn()
+		content = c.stringColumn()
+	}
+}
+
+test('index DSL with where and include', () => {
+	const schema = createSchema(IndexModel)
+	const indexes = schema.model.entities.Article.indexes
+	expect(indexes).toHaveLength(4)
+	expect(indexes).toEqual(expect.arrayContaining([
+		{ fields: ['title'] },
+		{ fields: ['title'], where: 'title IS NOT NULL' },
+		{ fields: ['title'], include: ['content'] },
+		{ fields: ['title'], include: ['content'], where: 'published', method: 'btree' },
+	]))
+})
+
+namespace IndexColumnOptionsModel {
+	@c.Index({ fields: ['title', { field: 'rank', order: 'desc', nulls: 'last' }] })
+	@c.Index({ fields: [{ field: 'title', opClass: 'text_pattern_ops' }] })
+	export class Article {
+		title = c.stringColumn()
+		rank = c.intColumn()
+	}
+}
+
+test('index DSL with per-column options normalizes to fields + columnOptions', () => {
+	const schema = createSchema(IndexColumnOptionsModel)
+	const indexes = schema.model.entities.Article.indexes
+	expect(indexes).toHaveLength(2)
+	expect(indexes).toEqual(expect.arrayContaining([
+		{ fields: ['title', 'rank'], columnOptions: { rank: { order: 'desc', nulls: 'last' } } },
+		{ fields: ['title'], columnOptions: { title: { opClass: 'text_pattern_ops' } } },
+	]))
+})
+
 namespace StrictModel {
 	export class Genre {
 		name = c.stringColumn()
@@ -113,7 +155,56 @@ test('strict test', () => {
 			settings: settingsPresets['v1.3'],
 		}), { strict: true })
 
-	expect(cb).toThrow(`Strict schema validation failed: 
+	expect(cb).toThrow(`Strict schema validation failed:
 - Book.genre: inverse side of the relation is not defined.
 - Book.genre: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`)
 })
+
+namespace StrictViewModel {
+	export class Author {
+		name = c.stringColumn()
+		stats = c.oneHasOneInverse(AuthorStats, 'author')
+	}
+
+	@c.View('SELECT 1')
+	export class AuthorStats {
+		author = c.oneHasOne(Author, 'stats')
+		postCount = c.intColumn().notNull()
+	}
+}
+
+test('strict test: onDelete is not required on a view entity relation', () => {
+	const cb = () =>
+		createSchema(StrictViewModel, schema => ({
+			...schema,
+			settings: settingsPresets['v1.3'],
+		}), { strict: true })
+
+	// AuthorStats.author has an inverse side defined and is a view relation, so neither the
+	// inverse-side nor the onDelete strict checks should fire.
+	expect(cb).not.toThrow()
+})
+
+namespace StrictViewWithOnDeleteModel {
+	export class Author {
+		name = c.stringColumn()
+		stats = c.oneHasOneInverse(AuthorStats, 'author')
+	}
+
+	@c.View('SELECT 1')
+	export class AuthorStats {
+		author = c.oneHasOne(Author, 'stats').cascadeOnDelete()
+		postCount = c.intColumn().notNull()
+	}
+}
+
+test('strict test: onDelete must not be set on a view entity relation', () => {
+	const cb = () =>
+		createSchema(StrictViewWithOnDeleteModel, schema => ({
+			...schema,
+			settings: settingsPresets['v1.3'],
+		}), { strict: true })
+
+	expect(cb).toThrow(`Strict schema validation failed:
+- AuthorStats.author: onDelete behaviour must not be set on a relation of a view entity. Views are read-only and have no delete semantics.`)
+})

package/tests/cases/unit/extendEntity.test.ts

@@ -1,8 +1,8 @@
 import { Model } from '@contember/schema'
 import { expect, test } from 'bun:test'
-import { c, createSchema } from '../../../src'
-import { extendEntity, FieldDefinition } from '../../../src/model/definition'
-import { DecoratorFunction } from '../../../src/utils'
+import { c, createSchema } from '../../../src/index.js'
+import { extendEntity, FieldDefinition } from '../../../src/model/definition/index.js'
+import { DecoratorFunction } from '../../../src/utils/index.js'
 
 namespace ExtendedModel {
 	export class Article {

package/tests/cases/unit/numericColumn.test.ts

@@ -0,0 +1,31 @@
+import { expect, test } from 'bun:test'
+import { c, createSchema } from '../../../src/index.js'
+import { Model } from '@contember/schema'
+
+namespace NumericModel {
+	export class Product {
+		price = c.numericColumn(20, 9).notNull()
+		discount = c.numericColumn(5, 2)
+	}
+}
+
+test('numericColumn produces numeric(precision, scale)', () => {
+	const schema = createSchema(NumericModel)
+	const fields = schema.model.entities.Product.fields
+
+	expect(fields.price).toMatchObject({
+		name: 'price',
+		columnName: 'price',
+		type: Model.ColumnType.Numeric,
+		columnType: 'numeric(20, 9)',
+		nullable: false,
+	})
+
+	expect(fields.discount).toMatchObject({
+		name: 'discount',
+		columnName: 'discount',
+		type: Model.ColumnType.Numeric,
+		columnType: 'numeric(5, 2)',
+		nullable: true,
+	})
+})

package/tests/cases/unit/orderBy.test.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
 import { describe, expect, test } from 'bun:test'
-import { c, createSchema } from '../../../src'
+import { c, createSchema } from '../../../src/index.js'
 
 const assert = {
 	deepEqual: (a: any, b: any) => expect(a).toStrictEqual(b),

package/tests/cases/unit/readAclDefinitions.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test'
-import { c, createSchema } from '../../../src'
+import { c, createSchema } from '../../../src/index.js'
 import { Acl, Model } from '@contember/schema'
 
 namespace SimpleModel {

package/tests/cases/unit/readActions.test.ts

@@ -1,6 +1,6 @@
-import { c } from '../../../src'
+import { c } from '../../../src/index.js'
 import { expect, test } from 'bun:test'
-import { createActions } from '../../../src/actions/definition'
+import { createActions } from '../../../src/actions/definition/index.js'
 
 namespace SimpleActions {
 	@c.Watch({