@contember/schema-utils 1.3.0-alpha.6 → 1.3.0-alpha.8

package/src/validation/ModelValidator.ts

@@ -7,7 +7,7 @@ const RESERVED_WORDS = ['and', 'or', 'not']
 
 
 export class ModelValidator {
-	constructor(private readonly model: Model.Schema) {}
+	constructor(private readonly model: Model.Schema) { }
 
 	public validate(): ValidationError[] {
 		const errorBuilder = new ErrorBuilder([], [])
@@ -54,15 +54,10 @@ export class ModelValidator {
 	}
 
 	private validateUniqueConstraints(uniqueConstraints: Model.Entity['unique'], fields: Set<string>, errors: ErrorBuilder): void {
-		for (const [constraintName, constraint] of Object.entries(uniqueConstraints)) {
-			const uniqueErrors = errors.for(constraintName)
-			if (constraint.name !== constraintName) {
-				uniqueErrors.add('MODEL_NAME_MISMATCH', `Constraint name ${constraint.name} does not match the name in a map "${constraintName}"`)
-				continue
-			}
+		for (const constraint of uniqueConstraints) {
 			for (const field of constraint.fields) {
 				if (!fields.has(field)) {
-					uniqueErrors.add('MODEL_UNDEFINED_FIELD', `Referenced field ${field} in a constraint does not exists`)
+					errors.add('MODEL_UNDEFINED_FIELD', `Referenced field ${field} in a constraint does not exists`)
 				}
 			}
 		}
@@ -79,7 +74,7 @@ export class ModelValidator {
 		}
 	}
 
-	private validateRelation(partialEntity: Model.Entity, field: Model.AnyRelation, errors: ErrorBuilder):  void {
+	private validateRelation(partialEntity: Model.Entity, field: Model.AnyRelation, errors: ErrorBuilder): void {
 		const entityName = partialEntity.name
 		const targetEntityName = field.target
 		const targetEntity = this.model.entities[targetEntityName] || undefined
@@ -148,7 +143,7 @@ export class ModelValidator {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} inverse relation is not set`)
 			}
 			if (targetField.inversedBy !== field.name) {
-				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} exepcted, ${targetField.target}::${targetField.inversedBy} given`)
+				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.inversedBy} given`)
 			}
 			if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -185,7 +180,7 @@ export class ModelValidator {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} owning relation is not set`)
 				}
 				if (targetField.ownedBy !== field.name) {
-					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} exepcted, ${targetField.target}::${targetField.ownedBy} given`)
+					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.ownedBy} given`)
 				}
 				if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -259,32 +254,13 @@ export class ModelValidator {
 					}
 					aliasedTypes.set(column.typeAlias, column.type)
 				},
-				visitManyHasManyInverse: () => {},
-				visitOneHasMany: () => {},
-				visitOneHasOneInverse: () => {},
-				visitOneHasOneOwning: () => {},
-				visitManyHasOne: () => {},
+				visitManyHasManyInverse: () => { },
+				visitOneHasMany: () => { },
+				visitOneHasOneInverse: () => { },
+				visitOneHasOneOwning: () => { },
+				visitManyHasOne: () => { },
 			})
 		}
-		for (const entity of entities) {
-			const entityErrorBuilder = errorBuilder.for(entity.name)
-			for (const index of Object.values(entity.indexes)) {
-				const description = `index name ${index.name} of entity ${entity.name}`
-				if (relationNames[index.name]) {
-					entityErrorBuilder.add('MODEL_NAME_COLLISION', `${description} collides with ${relationNames[index.name]}`)
-				} else {
-					relationNames[index.name] = description
-				}
-			}
-			for (const unique of Object.values(entity.unique)) {
-				const description = `unique index name ${unique.name} of entity ${entity.name}`
-				if (relationNames[unique.name]) {
-					entityErrorBuilder.add('MODEL_NAME_COLLISION', `${description} collides with ${relationNames[unique.name]}`)
-				} else {
-					relationNames[unique.name] = description
-				}
-			}
-		}
 	}
 }
 

package/tests/cases/unit/__snapshots__/laxSchemaConverter.test.ts.snap

@@ -45,12 +45,12 @@ exports[`lax schema converter basic 1`] = `
             "type": "String",
           },
         },
-        "indexes": {},
+        "indexes": [],
         "name": "Article",
         "primary": "id",
         "primaryColumn": "id",
         "tableName": "article",
-        "unique": {},
+        "unique": [],
       },
     },
     "enums": {
@@ -117,12 +117,12 @@ exports[`lax schema converter many-has-many 1`] = `
             "type": "String",
           },
         },
-        "indexes": {},
+        "indexes": [],
         "name": "Article",
         "primary": "id",
         "primaryColumn": "id",
         "tableName": "article",
-        "unique": {},
+        "unique": [],
       },
       "Tag": {
         "eventLog": {
@@ -143,12 +143,12 @@ exports[`lax schema converter many-has-many 1`] = `
             "type": "Uuid",
           },
         },
-        "indexes": {},
+        "indexes": [],
         "name": "Tag",
         "primary": "id",
         "primaryColumn": "id",
         "tableName": "tag",
-        "unique": {},
+        "unique": [],
       },
     },
     "enums": {},
@@ -200,12 +200,12 @@ exports[`lax schema converter one-has-many 1`] = `
             "type": "String",
           },
         },
-        "indexes": {},
+        "indexes": [],
         "name": "Article",
         "primary": "id",
         "primaryColumn": "id",
         "tableName": "article",
-        "unique": {},
+        "unique": [],
       },
       "Category": {
         "eventLog": {
@@ -226,12 +226,12 @@ exports[`lax schema converter one-has-many 1`] = `
             "type": "Uuid",
           },
         },
-        "indexes": {},
+        "indexes": [],
         "name": "Category",
         "primary": "id",
         "primaryColumn": "id",
         "tableName": "category",
-        "unique": {},
+        "unique": [],
       },
     },
     "enums": {},
@@ -283,12 +283,12 @@ exports[`lax schema converter one-has-one 1`] = `
             "type": "String",
           },
         },
-        "indexes": {},
+        "indexes": [],
         "name": "Article",
         "primary": "id",
         "primaryColumn": "id",
         "tableName": "article",
-        "unique": {},
+        "unique": [],
       },
       "Content": {
         "eventLog": {
@@ -310,12 +310,12 @@ exports[`lax schema converter one-has-one 1`] = `
             "type": "Uuid",
           },
         },
-        "indexes": {},
+        "indexes": [],
         "name": "Content",
         "primary": "id",
         "primaryColumn": "id",
         "tableName": "content",
-        "unique": {},
+        "unique": [],
       },
     },
     "enums": {},

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

@@ -4,73 +4,6 @@ import { ModelValidator } from '../../../src'
 
 
 
-test('index name collision', () => {
-	const model: Model.Schema = {
-		enums: {},
-		entities: {
-			Foo: {
-				fields: {
-					id: {
-						columnName: 'id',
-						name: 'id',
-						nullable: false,
-						type: Model.ColumnType.Uuid,
-						columnType: 'uuid',
-					},
-				},
-				name: 'Foo',
-				primary: 'id',
-				primaryColumn: 'id',
-				tableName: 'foo',
-				unique: {},
-				eventLog: {
-					enabled: true,
-				},
-				indexes: {
-					test: { fields: ['id'], name: 'test' },
-				},
-			},
-			Bar: {
-				fields: {
-					id: {
-						columnName: 'id',
-						name: 'id',
-						nullable: false,
-						type: Model.ColumnType.Uuid,
-						columnType: 'uuid',
-					},
-				},
-				name: 'Bar',
-				primary: 'id',
-				primaryColumn: 'id',
-				tableName: 'bar',
-				unique: {
-					test: { fields: ['id'], name: 'test' },
-				},
-				eventLog: {
-					enabled: true,
-				},
-				indexes: {
-					foo: { fields: ['id'], name: 'foo' },
-				},
-			},
-		},
-	}
-	const validator = new ModelValidator(model)
-	assert.deepStrictEqual(validator.validate(), [
-		{
-			code: 'MODEL_NAME_COLLISION',
-			message: 'index name foo of entity Bar collides with table name foo of entity Foo',
-			path: ['entities', 'Bar'],
-		},
-		{
-			code: 'MODEL_NAME_COLLISION',
-			message: 'unique index name test of entity Bar collides with index name test of entity Foo',
-			path: ['entities', 'Bar'],
-		},
-	])
-})
-
 
 test('"meta" collision', () => {
 	const model: Model.Schema = {
@@ -90,9 +23,9 @@ test('"meta" collision', () => {
 				primary: 'id',
 				primaryColumn: 'id',
 				tableName: 'foo',
-				unique: {},
+				unique: [],
 				eventLog: { enabled: true },
-				indexes: {},
+				indexes: [],
 			},
 			FooMeta: {
 				fields: {
@@ -108,9 +41,9 @@ test('"meta" collision', () => {
 				primary: 'id',
 				primaryColumn: 'id',
 				tableName: 'foo_meta',
-				unique: {},
+				unique: [],
 				eventLog: { enabled: true },
-				indexes: {},
+				indexes: [],
 			},
 			BarMeta: {
 				fields: {
@@ -126,9 +59,9 @@ test('"meta" collision', () => {
 				primary: 'id',
 				primaryColumn: 'id',
 				tableName: 'bar',
-				unique: {},
+				unique: [],
 				eventLog: { enabled: true },
-				indexes: {},
+				indexes: [],
 			},
 		},
 	}

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

@@ -0,0 +1,100 @@
+import { beforeAll, describe, expect, test } from 'vitest'
+import { printJsValue } from '../../../src/utils/printJsValue'
+
+beforeAll(() => {
+	expect.addSnapshotSerializer({
+		test: val => typeof val === 'string',
+		print: val => String(val),
+	})
+})
+
+describe('printJsValue', () => {
+	test('string', () => {
+		expect(printJsValue('foobar')).toMatchInlineSnapshot(`'foobar'`)
+	})
+
+	test('string escape', () => {
+		expect(printJsValue('foo\'bar')).toMatchInlineSnapshot(`'foo\\'bar'`)
+	})
+
+	test('number', () => {
+		expect(printJsValue(11)).toMatchInlineSnapshot(`11`)
+	})
+
+	test('boolean', () => {
+		expect(printJsValue(true)).toMatchInlineSnapshot(`true`)
+	})
+
+	test('null', () => {
+		expect(printJsValue(null)).toMatchInlineSnapshot(`null`)
+	})
+
+	test('inline array', () => {
+		expect(printJsValue([1, 2, 3])).toMatchInlineSnapshot(`[1, 2, 3]`)
+	})
+	test('block array', () => {
+		expect(printJsValue([1, 2, 3], () => true)).toMatchInlineSnapshot(`
+			[
+				1,
+				2,
+				3,
+			]
+		`)
+	})
+
+	test('inline object', () => {
+		expect(printJsValue({ a: 1, b: 2 })).toMatchInlineSnapshot('{ a: 1, b: 2 }')
+	})
+
+	test('block object', () => {
+		expect(printJsValue({ a: 1, b: 2 }, () => true)).toMatchInlineSnapshot(`
+			{
+				a: 1,
+				b: 2,
+			}
+		`)
+	})
+
+	test('nested block object', () => {
+		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, () => true)).toMatchInlineSnapshot(`
+			{
+				a: 1,
+				b: {
+					c: {
+						d: {
+							e: 1,
+						},
+					},
+				},
+			}
+		`)
+	})
+
+
+	test('one level nested block object', () => {
+		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, (_, path) => path.length === 0)).toMatchInlineSnapshot(`
+			{
+				a: 1,
+				b: { c: { d: { e: 1 } } },
+			}
+		`)
+	})
+
+	test('nested block object and arr', () => {
+		expect(printJsValue({ a: 1, b: [2, { c: 4 }, [5, 6]] }, () => true)).toMatchInlineSnapshot(`
+			{
+				a: 1,
+				b: [
+					2,
+					{
+						c: 4,
+					},
+					[
+						5,
+						6,
+					],
+				],
+			}
+		`)
+	})
+})

package/tests/cases/unit/schemas/acl.ts

@@ -0,0 +1,34 @@
+import { SchemaDefinition as def, AclDefinition as acl } from '@contember/schema-definition'
+
+export const readerRole = acl.createRole('reader', { stages: '*' })
+
+export const editorRole = acl.createRole('editor', { stages: '*' })
+
+export const categoryEditorVariable = acl.createEntityVariable('category', 'Category', editorRole)
+
+
+@acl.allow(readerRole, {
+	read: true,
+})
+@acl.allow(editorRole, {
+	when: { category: { id: categoryEditorVariable } },
+	read: true,
+	create: ['title', 'category'],
+	update: ['title', 'category'],
+})
+export class Article {
+	title = def.stringColumn()
+	deletedAt = def.dateTimeColumn()
+	category = def.manyHasOne(Category)
+}
+
+
+@acl.allow(readerRole, {
+	read: true,
+})
+@acl.allow(editorRole, {
+	read: true,
+})
+export class Category {
+	name = def.stringColumn()
+}

package/tests/cases/unit/schemas/basic.ts

@@ -1,4 +1,4 @@
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { SchemaDefinition as def, AclDefinition as acl } from '@contember/schema-definition'
 
 export class Article {
 	title = def.stringColumn()

package/tests/cases/unit/schemas/enum.ts

@@ -1,4 +1,4 @@
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { SchemaDefinition as def, AclDefinition as acl } from '@contember/schema-definition'
 
 export const articleState = def.createEnum('draft', 'published')
 

package/tests/cases/unit/schemas/relations.ts

@@ -1,4 +1,4 @@
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { SchemaDefinition as def, AclDefinition as acl } from '@contember/schema-definition'
 
 export class Article {
 	title = def.stringColumn()

package/tests/cases/unit/schemas/unique.ts

@@ -1,4 +1,4 @@
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { SchemaDefinition as def, AclDefinition as acl } from '@contember/schema-definition'
 
 @def.Unique('title')
 export class Article {

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

@@ -1,12 +1,13 @@
 import { createSchema } from '@contember/schema-definition'
-import { test, expect } from 'vitest'
+import { expect, test } from 'vitest'
 import * as basic from './schemas/basic'
 import * as relations from './schemas/relations'
 import * as unique from './schemas/unique'
 import * as enum_ from './schemas/enum'
+import * as acl from './schemas/acl'
 import { readFile, writeFile } from 'fs/promises'
 import { join } from 'path'
-import { TsDefinitionGenerator } from '../../../src'
+import { DefinitionCodeGenerator } from '../../../src/definition-generator/DefinitionCodeGenerator'
 
 
 const tests = [
@@ -14,13 +15,14 @@ const tests = [
 	['relations', relations],
 	['unique', unique],
 	['enum', enum_],
+	['acl', acl],
 ] as const
 for (const [name, def] of tests) {
 	test(`generate schema: ${name}`, async () => {
 		const schema = createSchema(def)
-		const generator = new TsDefinitionGenerator(schema)
+		const generator = new DefinitionCodeGenerator()
 		const content = await readFile(join(__dirname, `schemas/${name}.ts`), 'utf-8')
-		const generated = generator.generate()
+		const generated = generator.generate(schema)
 		try {
 			expect(generated).toBe(content)
 		} catch (e) {

package/dist/src/model/NamingHelper.d.ts

@@ -1,9 +0,0 @@
-export declare class NamingHelper {
-    static createForeignKeyIndexName(tableName: string, column: string): string;
-    static createJunctionTablePrimaryConstraintName(tableName: string): string;
-    static createForeignKeyName(fromTable: string, fromColumn: string, toTable: string, toColumn: string): string;
-    static createIndexName: (entityName: string, fields: readonly string[]) => string;
-    static createUniqueConstraintName: (entityName: string, fields: readonly string[]) => string;
-    private static createUniqueSuffix;
-}
-//# sourceMappingURL=NamingHelper.d.ts.map

package/dist/src/model/NamingHelper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NamingHelper.d.ts","sourceRoot":"","sources":["../../../src/model/NamingHelper.ts"],"names":[],"mappings":"AAIA,qBAAa,YAAY;WACV,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;WAK3D,wCAAwC,CAAC,SAAS,EAAE,MAAM;WAK1D,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAOpH,OAAc,eAAe,eAAgB,MAAM,UAAU,SAAS,MAAM,EAAE,KAAG,MAAM,CAKtF;IAED,OAAc,0BAA0B,eAAgB,MAAM,UAAU,SAAS,MAAM,EAAE,KAAG,MAAM,CAKjG;IAED,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAGhC;CACD"}

package/dist/src/model/NamingHelper.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NamingHelper = void 0;
-const sha256_1 = __importDefault(require("crypto-js/sha256"));
-const enc_hex_1 = __importDefault(require("crypto-js/enc-hex"));
-class NamingHelper {
-    static createForeignKeyIndexName(tableName, column) {
-        // format matches https://github.com/salsita/node-pg-migrate/blob/9331f6fda98795e3f3733461f9b71345168b99d8/src/operations/indexes.ts#L21
-        return `${tableName}_${column}_index`;
-    }
-    static createJunctionTablePrimaryConstraintName(tableName) {
-        // format matches https://github.com/salsita/node-pg-migrate/blob/9331f6fda98795e3f3733461f9b71345168b99d8/src/operations/tables.ts#L204
-        return `${tableName}_pkey`;
-    }
-    static createForeignKeyName(fromTable, fromColumn, toTable, toColumn) {
-        return 'fk_'
-            + fromTable + '_'
-            + fromColumn + '_'
-            + this.createUniqueSuffix([fromTable, fromColumn, toTable, toColumn]);
-    }
-}
-exports.NamingHelper = NamingHelper;
-_a = NamingHelper;
-NamingHelper.createIndexName = (entityName, fields) => {
-    return 'idx_'
-        + entityName + '_'
-        + fields.join('_') + '_'
-        + _a.createUniqueSuffix([entityName, ...fields]);
-};
-NamingHelper.createUniqueConstraintName = (entityName, fields) => {
-    return 'unique_'
-        + entityName + '_'
-        + fields.join('_') + '_'
-        + _a.createUniqueSuffix([entityName, ...fields]);
-};
-NamingHelper.createUniqueSuffix = (values) => {
-    const uniqueSuffix = (0, sha256_1.default)(JSON.stringify(values)).toString(enc_hex_1.default);
-    return uniqueSuffix.slice(0, 6);
-};
-//# sourceMappingURL=NamingHelper.js.map

package/dist/src/model/NamingHelper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NamingHelper.js","sourceRoot":"","sources":["../../../src/model/NamingHelper.ts"],"names":[],"mappings":";;;;;;;AAAA,8DAAqC;AACrC,gEAAsC;AAGtC,MAAa,YAAY;IACjB,MAAM,CAAC,yBAAyB,CAAC,SAAiB,EAAE,MAAc;QACxE,wIAAwI;QACxI,OAAO,GAAG,SAAS,IAAI,MAAM,QAAQ,CAAA;IACtC,CAAC;IAEM,MAAM,CAAC,wCAAwC,CAAC,SAAiB;QACvE,wIAAwI;QACxI,OAAO,GAAG,SAAS,OAAO,CAAA;IAC3B,CAAC;IAEM,MAAM,CAAC,oBAAoB,CAAC,SAAiB,EAAE,UAAkB,EAAE,OAAe,EAAE,QAAgB;QAC1G,OAAO,KAAK;cACT,SAAS,GAAG,GAAG;cACf,UAAU,GAAG,GAAG;cAChB,IAAI,CAAC,kBAAkB,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAA;IACvE,CAAC;;AAhBF,oCAoCC;;AAlBc,4BAAe,GAAG,CAAC,UAAkB,EAAE,MAAyB,EAAU,EAAE;IACzF,OAAO,MAAM;UACV,UAAU,GAAG,GAAG;UAChB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG;UACtB,EAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,EAAE,GAAG,MAAM,CAAC,CAAC,CAAA;AACpD,CAAC,CAAA;AAEa,uCAA0B,GAAG,CAAC,UAAkB,EAAE,MAAyB,EAAU,EAAE;IACpG,OAAO,SAAS;UACb,UAAU,GAAG,GAAG;UAChB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG;UACtB,EAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,EAAE,GAAG,MAAM,CAAC,CAAC,CAAA;AACpD,CAAC,CAAA;AAEc,+BAAkB,GAAG,CAAC,MAAgB,EAAU,EAAE;IAChE,MAAM,YAAY,GAAG,IAAA,gBAAM,EAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,iBAAM,CAAC,CAAA;IACpE,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAChC,CAAC,CAAA"}

package/src/model/NamingHelper.ts

@@ -1,41 +0,0 @@
-import Sha256 from 'crypto-js/sha256'
-import EncHex from 'crypto-js/enc-hex'
-
-
-export class NamingHelper {
-	public static createForeignKeyIndexName(tableName: string, column: string) {
-		// format matches https://github.com/salsita/node-pg-migrate/blob/9331f6fda98795e3f3733461f9b71345168b99d8/src/operations/indexes.ts#L21
-		return `${tableName}_${column}_index`
-	}
-
-	public static createJunctionTablePrimaryConstraintName(tableName: string) {
-		// format matches https://github.com/salsita/node-pg-migrate/blob/9331f6fda98795e3f3733461f9b71345168b99d8/src/operations/tables.ts#L204
-		return `${tableName}_pkey`
-	}
-
-	public static createForeignKeyName(fromTable: string, fromColumn: string, toTable: string, toColumn: string): string {
-		return 'fk_'
-			+ fromTable + '_'
-			+ fromColumn + '_'
-			+ this.createUniqueSuffix([fromTable, fromColumn, toTable, toColumn])
-	}
-
-	public static createIndexName = (entityName: string, fields: readonly string[]): string => {
-		return 'idx_'
-			+ entityName + '_'
-			+ fields.join('_') + '_'
-			+ this.createUniqueSuffix([entityName, ...fields])
-	}
-
-	public static createUniqueConstraintName = (entityName: string, fields: readonly string[]): string => {
-		return 'unique_'
-			+ entityName + '_'
-			+ fields.join('_') + '_'
-			+ this.createUniqueSuffix([entityName, ...fields])
-	}
-
-	private static createUniqueSuffix = (values: string[]): string => {
-		const uniqueSuffix = Sha256(JSON.stringify(values)).toString(EncHex)
-		return uniqueSuffix.slice(0, 6)
-	}
-}