@contember/schema-definition 1.2.0-alpha.9 → 1.2.0-beta.2

package/src/acl/definition/variables.ts

@@ -1,5 +1,5 @@
 import { Role } from './roles'
-import { Acl } from '@contember/schema'
+import { Acl, Input } from '@contember/schema'
 
 export class VariableDefinition<Name extends string = string, Roles extends Role<string> = Role<string>, Variable extends Acl.Variable = Acl.Variable> {
 	constructor(
@@ -10,24 +10,24 @@ export class VariableDefinition<Name extends string = string, Roles extends Role
 	}
 }
 
-
 export const createEntityVariable = <R extends Role<string>, Name extends string>(
 	name: Name,
 	entityName: string,
 	roles: R | R[],
+	fallback?: Input.Condition,
 ): VariableDefinition<Name, R, Acl.EntityVariable> => {
 	return new VariableDefinition(
 		name,
 		Array.isArray(roles) ? roles : [roles],
-		{ type: Acl.VariableType.entity, entityName },
+		{ type: Acl.VariableType.entity, entityName, ...(fallback ? { fallback } : {}) },
 	)
 }
 
-
 export const createPredefinedVariable = <R extends Role<string>, Name extends string>(
 	name: Name,
 	value: Acl.PredefinedVariableValue,
 	roles: R | R[],
+	fallback?: Input.Condition,
 ): VariableDefinition<Name, R, Acl.EntityVariable> => {
 	return new VariableDefinition(
 		name,
@@ -39,10 +39,11 @@ export const createPredefinedVariable = <R extends Role<string>, Name extends st
 export const createConditionVariable = <R extends Role<string>, Name extends string>(
 	name: Name,
 	roles: R | R[],
+	fallback?: Input.Condition,
 ): VariableDefinition<Name, R, Acl.ConditionVariable> => {
 	return new VariableDefinition(
 		name,
 		Array.isArray(roles) ? roles : [roles],
-		{ type: Acl.VariableType.condition  },
+		{ type: Acl.VariableType.condition, ...(fallback ? { fallback } : {}) },
 	)
 }

package/src/createSchema.ts

@@ -2,11 +2,12 @@ import { SchemaDefinition } from './model'
 import * as InputValidation from './validation'
 import * as AclDefinition from './acl/definition'
 import { Schema } from '@contember/schema'
+import { emptySchema } from '@contember/schema-utils'
 
 export const createSchema = (definitions: Record<string, any>, modifyCallback?: (schema: Schema) => Schema): Schema => {
 	const model = SchemaDefinition.createModel(definitions)
 	const validation = InputValidation.parseDefinition(definitions)
 	const acl = AclDefinition.createAcl(definitions, model)
-	const schema = { model, validation, acl }
+	const schema = { ...emptySchema, model, validation, acl }
 	return modifyCallback ? modifyCallback(schema) : schema
 }

package/src/model/builder/SchemaBuilder.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
 import EntityBuilder from './EntityBuilder'
-import { DefaultNamingConventions, NamingConventions } from '../definition/NamingConventions'
+import { DefaultNamingConventions, NamingConventions } from '@contember/schema-utils'
 import SchemaBuilderInternal from './SchemaBuilderInternal'
 import { EntityConfigurator } from './types'
 

package/src/model/builder/SchemaBuilderInternal.ts

@@ -8,7 +8,7 @@ import ManyHasManyProcessor from './internal/ManyHasManyProcessor'
 import OneHasOneProcessor from './internal/OneHasOneProcessor'
 import OneHasManyProcessor from './internal/OneHasManyProcessor'
 import ManyHasOneProcessor from './internal/ManyHasOneProcessor'
-import { NamingConventions } from './../definition/NamingConventions'
+import { NamingConventions } from '@contember/schema-utils'
 import FieldBuilder from './FieldBuilder'
 
 export default class SchemaBuilderInternal {

package/src/model/builder/internal/ColumnProcessor.ts

@@ -1,8 +1,7 @@
 import FieldProcessor from './FieldProcessor'
 import ColumnBuilder from '../ColumnBuilder'
-import { NamingConventions } from '../../definition/NamingConventions'
 import { Model } from '@contember/schema'
-import { getColumnType } from '../../utils/getColumnType'
+import { NamingConventions, resolveDefaultColumnType } from '@contember/schema-utils'
 
 export default class ColumnProcessor implements FieldProcessor<ColumnBuilder.Options> {
 	private conventions: NamingConventions
@@ -34,7 +33,7 @@ export default class ColumnProcessor implements FieldProcessor<ColumnBuilder.Opt
 		return {
 			...common,
 			type,
-			columnType: getColumnType(type),
+			columnType: resolveDefaultColumnType(type),
 			...(options.typeAlias !== undefined ? { typeAlias: options.typeAlias } : {}),
 		}
 	}

package/src/model/builder/internal/ManyHasManyProcessor.ts

@@ -1,7 +1,7 @@
 import FieldProcessor from './FieldProcessor'
 import ManyHasManyBuilder from '../ManyHasManyBuilder'
 import { Model } from '@contember/schema'
-import { NamingConventions } from '../../definition/NamingConventions'
+import { NamingConventions } from '@contember/schema-utils'
 
 export default class ManyHasManyProcessor implements FieldProcessor<ManyHasManyBuilder.Options> {
 	private conventions: NamingConventions

package/src/model/builder/internal/ManyHasOneProcessor.ts

@@ -1,7 +1,7 @@
 import FieldProcessor from './FieldProcessor'
 import { Model } from '@contember/schema'
 import ManyHasOneBuilder from '../ManyHasOneBuilder'
-import { NamingConventions } from '../../definition/NamingConventions'
+import { NamingConventions } from '@contember/schema-utils'
 
 export default class ManyHasOneProcessor implements FieldProcessor<ManyHasOneBuilder.Options> {
 	private conventions: NamingConventions

package/src/model/builder/internal/OneHasManyProcessor.ts

@@ -1,7 +1,7 @@
 import FieldProcessor from './FieldProcessor'
 import OneHasManyBuilder from '../OneHasManyBuilder'
 import { Model } from '@contember/schema'
-import { NamingConventions } from '../../definition/NamingConventions'
+import { NamingConventions } from '@contember/schema-utils'
 
 export default class OneHasManyProcessor implements FieldProcessor<OneHasManyBuilder.Options> {
 	private conventions: NamingConventions

package/src/model/builder/internal/OneHasOneProcessor.ts

@@ -1,7 +1,7 @@
 import OneHasOneBuilder from '../OneHasOneBuilder'
 import FieldProcessor from './FieldProcessor'
 import { Model } from '@contember/schema'
-import { NamingConventions } from '../../definition/NamingConventions'
+import { NamingConventions } from '@contember/schema-utils'
 
 export default class OneHasOneProcessor implements FieldProcessor<OneHasOneBuilder.Options> {
 	private conventions: NamingConventions

package/src/model/definition/ViewDefinition.ts

@@ -2,7 +2,7 @@ import { extendEntity } from './extensions'
 import { EntityConstructor } from './types'
 
 export const View = (sql: string, { dependencies }: { dependencies?: (() => EntityConstructor[]) | EntityConstructor[] } = {}) =>
-	extendEntity(({ entity, registry }) => {
+	extendEntity(({ entity, entityRegistry }) => {
 		const dependenciesResolved = typeof dependencies === 'function' ? dependencies() : dependencies
 		if (dependenciesResolved?.some(it => it === undefined)) {
 			throw `"undefined" value detected in dependencies of view entity ${entity.name}. This is possibly caused by circular imports.
@@ -18,7 +18,7 @@ dependencies: () => [MyEntity]
 			...entity,
 			view: {
 				sql,
-				...(dependenciesResolved ? { dependencies: dependenciesResolved.map(it => registry.getName(it)) } : {}),
+				...(dependenciesResolved ? { dependencies: dependenciesResolved.map(it => entityRegistry.getName(it)) } : {}),
 			},
 		})
 	})

package/src/model/definition/extensions.ts

@@ -1,10 +1,16 @@
 import { Model } from '@contember/schema'
 import { DecoratorFunction, EntityConstructor, FieldsDefinition } from './types'
-import { EntityRegistry } from './internal'
+import { EntityRegistry, EnumRegistry } from './internal'
+import { NamingConventions } from '@contember/schema-utils'
 
 interface EntityExtensionArgs {
 	entity: Model.Entity
 	definition: FieldsDefinition
+	conventions: NamingConventions
+	enumRegistry: EnumRegistry
+	entityRegistry: EntityRegistry
+
+	/** @deprecated use entityRegistry */
 	registry: EntityRegistry
 }
 

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

@@ -2,7 +2,7 @@ import { Model } from '@contember/schema'
 import { Interface } from '../types'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 import { EnumDefinition } from '../EnumDefinition'
-import { getColumnType } from '../../utils'
+import { resolveDefaultColumnType } from '@contember/schema-utils'
 
 export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 	type = 'ColumnDefinition' as const
@@ -34,8 +34,8 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 		return this.withOption('nullable', false)
 	}
 
-	public sequence(options?: Model.ColumnTypeDefinition['sequence']): Interface<ColumnDefinition> {
-		return this.withOption('sequence', options ?? { precedence: 'BY DEFAULT' })
+	public sequence(options?: Partial<Model.ColumnTypeDefinition['sequence']>): Interface<ColumnDefinition> {
+		return this.withOption('sequence', { precedence: 'BY DEFAULT', ...options })
 	}
 
 	public unique(): Interface<ColumnDefinition> {
@@ -79,7 +79,7 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 		return {
 			...common,
 			type: type,
-			columnType: columnType || getColumnType(type),
+			columnType: columnType || resolveDefaultColumnType(type),
 			...(typeAlias !== undefined ? { typeAlias } : {}),
 		}
 	}

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

@@ -1,5 +1,5 @@
 import { Model } from '@contember/schema'
-import { NamingConventions } from '../NamingConventions'
+import { NamingConventions } from '@contember/schema-utils'
 import { EntityRegistry, EnumRegistry } from '../internal'
 
 export abstract class FieldDefinition<O> {

package/src/model/definition/index.ts

@@ -2,10 +2,10 @@ import { EntityConstructor, Interface } from './types'
 import { Model } from '@contember/schema'
 import { EnumDefinition } from './EnumDefinition'
 import { SchemaBuilder } from './internal'
-import { DefaultNamingConventions } from './NamingConventions'
 import 'reflect-metadata'
 import { FieldDefinition } from './fieldDefinitions'
 import { isEntityConstructor } from '../../utils'
+import { DefaultNamingConventions } from '@contember/schema-utils'
 
 export * from './fieldDefinitions'
 export * from './EventLogDefinition'

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

@@ -1,9 +1,8 @@
 import { Model, Writable } from '@contember/schema'
-import { NamingHelper } from '@contember/schema-utils'
+import { NamingConventions, NamingHelper } from '@contember/schema-utils'
 import 'reflect-metadata'
 import { tuple } from '../../../utils'
 import { EntityConstructor, FieldsDefinition } from '../types'
-import { NamingConventions } from '../NamingConventions'
 import { EnumDefinition } from '../EnumDefinition'
 import { EntityRegistry } from './EntityRegistry'
 import { EnumRegistry } from './EnumRegistry'
@@ -61,7 +60,14 @@ export class SchemaBuilder {
 					enabled: true,
 				},
 			}
-			return applyEntityExtensions(definition, { entity,  definition: definitionInstance, registry: this.entityRegistry })
+			return applyEntityExtensions(definition, {
+				entity,
+				definition: definitionInstance,
+				registry: this.entityRegistry,
+				entityRegistry: this.entityRegistry,
+				conventions: this.conventions,
+				enumRegistry: this.enumRegistry,
+			})
 		})
 
 		return {

package/tests/unit/extendEntity.test.ts

@@ -0,0 +1,42 @@
+import { Model } from '@contember/schema'
+import { assert, test } from 'vitest'
+import { createSchema, SchemaDefinition as def } from '../../src'
+import { extendEntity, FieldDefinition } from '../../src/model/definition'
+import { DecoratorFunction } from '../../src/model/definition/types'
+
+namespace ExtendedModel {
+	export class Article {
+		title = def.stringColumn()
+	}
+
+	const addField = (name: string, field: FieldDefinition<any>): DecoratorFunction<any> => {
+		return extendEntity(({ entity, conventions, entityRegistry, enumRegistry }) => ({
+			...entity,
+			fields: {
+				...entity.fields,
+				[name]: field.createField({
+					name,
+					enumRegistry,
+					entityRegistry,
+					conventions,
+					entityName: entity.name,
+				}),
+			},
+		}))
+	}
+
+	addField('lead', def.stringColumn())(Article)
+}
+
+
+test('add a field to entity using an extension', () => {
+	const schema = createSchema(ExtendedModel)
+
+	assert.deepEqual(schema.model.entities.Article.fields.lead, {
+		columnName: 'lead',
+		name: 'lead',
+		columnType: 'text',
+		type: Model.ColumnType.String,
+		nullable: true,
+	})
+})

package/tests/unit/readAclDefinitions.test.ts

@@ -24,6 +24,32 @@ test('simple definitions', () => {
 	`)
 })
 
+
+namespace RoleOptions {
+	export const publicRole = acl.createRole('public', {
+		debug: true,
+		s3: {
+			foo: 'bar',
+		},
+	})
+}
+
+test('role options', () => {
+	const schema = createSchema(RoleOptions)
+	expect(schema.acl.roles.public).toMatchInlineSnapshot(`
+		{
+		  "debug": true,
+		  "entities": {},
+		  "s3": {
+		    "foo": "bar",
+		  },
+		  "stages": "*",
+		  "variables": {},
+		}
+	`)
+})
+
+
 namespace ModelWithPredicate {
 	export const publicRole = acl.createRole('public')
 
@@ -181,6 +207,72 @@ test('definition with multiple predicates on a single field', () => {
 })
 
 
+namespace ModelWithJoinedPredicateCollision {
+	export const publicRole = acl.createRole('public')
+
+	@acl.allow(publicRole, {
+		when: { isPublishedLoremIpsumDolorSitAmet: { eq: true } },
+		read: ['title'],
+	})
+	@acl.allow(publicRole, {
+		when: { isPublishedLoremIpsumDolorSitAmet: { eq: false } },
+		read: ['title', 'isPublishedLoremIpsumDolorSitAmet'],
+	})
+	@acl.allow(publicRole, {
+		when: { isPublishedLoremIpsumDolorSitAmet: { eq: false } },
+		read: ['isPublishedLoremIpsumDolorSitAmet'],
+	})
+	export class Book {
+		title = def.stringColumn()
+		isPublishedLoremIpsumDolorSitAmet = def.boolColumn()
+	}
+}
+
+test('definition with collision', () => {
+	const schema = createSchema(ModelWithJoinedPredicateCollision)
+	expect(schema.acl.roles.public.entities.Book).toMatchInlineSnapshot(`
+		{
+		  "operations": {
+		    "read": {
+		      "isPublishedLoremIpsumDolorSitAmet": "or_isPublishedLoremIpsumDolor_1",
+		      "title": "or_isPublishedLoremIpsumDolor",
+		    },
+		  },
+		  "predicates": {
+		    "or_isPublishedLoremIpsumDolor": {
+		      "or": [
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": false,
+		          },
+		        },
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": true,
+		          },
+		        },
+		      ],
+		    },
+		    "or_isPublishedLoremIpsumDolor_1": {
+		      "or": [
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": false,
+		          },
+		        },
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": false,
+		          },
+		        },
+		      ],
+		    },
+		  },
+		}
+	`)
+})
+
+
 namespace ModelWithMultipleRolesForSinglePredicate {
 	export const publicRole = acl.createRole('public')
 	export const adminRole = acl.createRole('admin')

package/dist/src/model/definition/NamingConventions.d.ts

@@ -1,17 +0,0 @@
-export interface NamingConventions {
-    getPrimaryField(): string;
-    getColumnName(fieldName: string): string;
-    getTableName(entityName: string): string;
-    getJoiningColumnName(relationName: string): string;
-    getJoiningTableName(entity: string, relation: string): string;
-    getJoiningTableColumnNames(owningEntity: string, owningRelation: string, inverseEntity: string, inverseRelation?: string): [string, string];
-}
-export declare class DefaultNamingConventions implements NamingConventions {
-    getPrimaryField(): string;
-    getColumnName(fieldName: string): string;
-    getTableName(entityName: string): string;
-    getJoiningColumnName(relationName: string): string;
-    getJoiningTableName(entity: string, relation: string): string;
-    getJoiningTableColumnNames(owningEntity: string, owningRelation: string, inverseEntity: string, inverseRelation?: string): [string, string];
-}
-//# sourceMappingURL=NamingConventions.d.ts.map

package/dist/src/model/definition/NamingConventions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NamingConventions.d.ts","sourceRoot":"","sources":["../../../../src/model/definition/NamingConventions.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IACjC,eAAe,IAAI,MAAM,CAAA;IAEzB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;IAExC,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;IAExC,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAA;IAElD,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;IAE7D,0BAA0B,CACzB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,eAAe,CAAC,EAAE,MAAM,GACtB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACnB;AAGD,qBAAa,wBAAyB,YAAW,iBAAiB;IACjE,eAAe,IAAI,MAAM;IAIzB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIxC,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAIxC,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAIlD,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI7D,0BAA0B,CACzB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,eAAe,CAAC,EAAE,MAAM,GACtB,CAAC,MAAM,EAAE,MAAM,CAAC;CAMnB"}

package/dist/src/model/definition/NamingConventions.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultNamingConventions = void 0;
-const toUnderscore = (s) => s.replace(/([A-Z]+)/g, (x, y) => '_' + y.toLowerCase()).replace(/^_/, '');
-class DefaultNamingConventions {
-    getPrimaryField() {
-        return 'id';
-    }
-    getColumnName(fieldName) {
-        return toUnderscore(fieldName);
-    }
-    getTableName(entityName) {
-        return toUnderscore(entityName);
-    }
-    getJoiningColumnName(relationName) {
-        return toUnderscore(relationName) + '_id';
-    }
-    getJoiningTableName(entity, relation) {
-        return toUnderscore(entity) + '_' + toUnderscore(relation);
-    }
-    getJoiningTableColumnNames(owningEntity, owningRelation, inverseEntity, inverseRelation) {
-        return [
-            toUnderscore(owningEntity) + '_id',
-            toUnderscore(inverseEntity === owningEntity ? owningRelation : inverseEntity) + '_id',
-        ];
-    }
-}
-exports.DefaultNamingConventions = DefaultNamingConventions;
-//# sourceMappingURL=NamingConventions.js.map

package/dist/src/model/definition/NamingConventions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NamingConventions.js","sourceRoot":"","sources":["../../../../src/model/definition/NamingConventions.ts"],"names":[],"mappings":";;;AAmBA,MAAM,YAAY,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;AAC7G,MAAa,wBAAwB;IACpC,eAAe;QACd,OAAO,IAAI,CAAA;IACZ,CAAC;IAED,aAAa,CAAC,SAAiB;QAC9B,OAAO,YAAY,CAAC,SAAS,CAAC,CAAA;IAC/B,CAAC;IAED,YAAY,CAAC,UAAkB;QAC9B,OAAO,YAAY,CAAC,UAAU,CAAC,CAAA;IAChC,CAAC;IAED,oBAAoB,CAAC,YAAoB;QACxC,OAAO,YAAY,CAAC,YAAY,CAAC,GAAG,KAAK,CAAA;IAC1C,CAAC;IAED,mBAAmB,CAAC,MAAc,EAAE,QAAgB;QACnD,OAAO,YAAY,CAAC,MAAM,CAAC,GAAG,GAAG,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;IAC3D,CAAC;IAED,0BAA0B,CACzB,YAAoB,EACpB,cAAsB,EACtB,aAAqB,EACrB,eAAwB;QAExB,OAAO;YACN,YAAY,CAAC,YAAY,CAAC,GAAG,KAAK;YAClC,YAAY,CAAC,aAAa,KAAK,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,aAAa,CAAC,GAAG,KAAK;SACrF,CAAA;IACF,CAAC;CACD;AAhCD,4DAgCC"}

package/dist/src/model/utils/getColumnType.d.ts

@@ -1,3 +0,0 @@
-import { Model } from '@contember/schema';
-export declare const getColumnType: (type: Exclude<Model.ColumnType, Model.ColumnType.Enum>) => string;
-//# sourceMappingURL=getColumnType.d.ts.map

package/dist/src/model/utils/getColumnType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getColumnType.d.ts","sourceRoot":"","sources":["../../../../src/model/utils/getColumnType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGzC,eAAO,MAAM,aAAa,SAAU,QAAQ,MAAM,UAAU,EAAE,MAAM,UAAU,CAAC,IAAI,CAAC,KAAG,MAqBtF,CAAA"}

package/dist/src/model/utils/getColumnType.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getColumnType = void 0;
-const schema_1 = require("@contember/schema");
-const utils_1 = require("../../utils");
-const getColumnType = (type) => {
-    switch (type) {
-        case schema_1.Model.ColumnType.Int:
-            return 'integer';
-        case schema_1.Model.ColumnType.Double:
-            return 'double precision';
-        case schema_1.Model.ColumnType.String:
-            return 'text';
-        case schema_1.Model.ColumnType.Uuid:
-            return 'uuid';
-        case schema_1.Model.ColumnType.Bool:
-            return 'boolean';
-        case schema_1.Model.ColumnType.DateTime:
-            return 'timestamptz';
-        case schema_1.Model.ColumnType.Date:
-            return 'date';
-        case schema_1.Model.ColumnType.Json:
-            return 'jsonb';
-        default:
-            return (0, utils_1.assertNever)(type);
-    }
-};
-exports.getColumnType = getColumnType;
-//# sourceMappingURL=getColumnType.js.map

package/dist/src/model/utils/getColumnType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getColumnType.js","sourceRoot":"","sources":["../../../../src/model/utils/getColumnType.ts"],"names":[],"mappings":";;;AAAA,8CAAyC;AACzC,uCAAyC;AAElC,MAAM,aAAa,GAAG,CAAC,IAAsD,EAAU,EAAE;IAC/F,QAAQ,IAAI,EAAE;QACb,KAAK,cAAK,CAAC,UAAU,CAAC,GAAG;YACxB,OAAO,SAAS,CAAA;QACjB,KAAK,cAAK,CAAC,UAAU,CAAC,MAAM;YAC3B,OAAO,kBAAkB,CAAA;QAC1B,KAAK,cAAK,CAAC,UAAU,CAAC,MAAM;YAC3B,OAAO,MAAM,CAAA;QACd,KAAK,cAAK,CAAC,UAAU,CAAC,IAAI;YACzB,OAAO,MAAM,CAAA;QACd,KAAK,cAAK,CAAC,UAAU,CAAC,IAAI;YACzB,OAAO,SAAS,CAAA;QACjB,KAAK,cAAK,CAAC,UAAU,CAAC,QAAQ;YAC7B,OAAO,aAAa,CAAA;QACrB,KAAK,cAAK,CAAC,UAAU,CAAC,IAAI;YACzB,OAAO,MAAM,CAAA;QACd,KAAK,cAAK,CAAC,UAAU,CAAC,IAAI;YACzB,OAAO,OAAO,CAAA;QACf;YACC,OAAO,IAAA,mBAAW,EAAC,IAAI,CAAC,CAAA;KACzB;AACF,CAAC,CAAA;AArBY,QAAA,aAAa,iBAqBzB"}

package/dist/src/model/utils/index.d.ts

@@ -1,2 +0,0 @@
-export * from './getColumnType';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/model/utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/model/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/dist/src/model/utils/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./getColumnType"), exports);
-//# sourceMappingURL=index.js.map

package/dist/src/model/utils/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/model/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAA+B"}

package/src/model/definition/NamingConventions.ts

@@ -1,53 +0,0 @@
-export interface NamingConventions {
-	getPrimaryField(): string
-
-	getColumnName(fieldName: string): string
-
-	getTableName(entityName: string): string
-
-	getJoiningColumnName(relationName: string): string
-
-	getJoiningTableName(entity: string, relation: string): string
-
-	getJoiningTableColumnNames(
-		owningEntity: string,
-		owningRelation: string,
-		inverseEntity: string,
-		inverseRelation?: string,
-	): [string, string]
-}
-
-const toUnderscore = (s: string) => s.replace(/([A-Z]+)/g, (x, y) => '_' + y.toLowerCase()).replace(/^_/, '')
-export class DefaultNamingConventions implements NamingConventions {
-	getPrimaryField(): string {
-		return 'id'
-	}
-
-	getColumnName(fieldName: string): string {
-		return toUnderscore(fieldName)
-	}
-
-	getTableName(entityName: string): string {
-		return toUnderscore(entityName)
-	}
-
-	getJoiningColumnName(relationName: string): string {
-		return toUnderscore(relationName) + '_id'
-	}
-
-	getJoiningTableName(entity: string, relation: string): string {
-		return toUnderscore(entity) + '_' + toUnderscore(relation)
-	}
-
-	getJoiningTableColumnNames(
-		owningEntity: string,
-		owningRelation: string,
-		inverseEntity: string,
-		inverseRelation?: string,
-	): [string, string] {
-		return [
-			toUnderscore(owningEntity) + '_id',
-			toUnderscore(inverseEntity === owningEntity ? owningRelation : inverseEntity) + '_id',
-		]
-	}
-}

package/src/model/utils/getColumnType.ts

@@ -1,25 +0,0 @@
-import { Model } from '@contember/schema'
-import { assertNever } from '../../utils'
-
-export const getColumnType = (type: Exclude<Model.ColumnType, Model.ColumnType.Enum>): string => {
-	switch (type) {
-		case Model.ColumnType.Int:
-			return 'integer'
-		case Model.ColumnType.Double:
-			return 'double precision'
-		case Model.ColumnType.String:
-			return 'text'
-		case Model.ColumnType.Uuid:
-			return 'uuid'
-		case Model.ColumnType.Bool:
-			return 'boolean'
-		case Model.ColumnType.DateTime:
-			return 'timestamptz'
-		case Model.ColumnType.Date:
-			return 'date'
-		case Model.ColumnType.Json:
-			return 'jsonb'
-		default:
-			return assertNever(type)
-	}
-}

package/src/model/utils/index.ts

@@ -1 +0,0 @@
-export * from './getColumnType'