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

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

@@ -0,0 +1,310 @@
+// Vitest Snapshot v1
+
+exports[`lax schema converter basic 1`] = `
+{
+  "acl": {
+    "roles": {},
+  },
+  "model": {
+    "entities": {
+      "Article": {
+        "eventLog": {
+          "enabled": true,
+        },
+        "fields": {
+          "content": {
+            "columnName": "content",
+            "columnType": "jsonb",
+            "name": "content",
+            "nullable": true,
+            "type": "Json",
+          },
+          "id": {
+            "columnName": "id",
+            "columnType": "uuid",
+            "name": "id",
+            "nullable": false,
+            "type": "Uuid",
+          },
+          "state": {
+            "columnName": "state",
+            "columnType": "ArticleState",
+            "name": "state",
+            "nullable": true,
+            "type": "Enum",
+          },
+          "title": {
+            "columnName": "title",
+            "columnType": "text",
+            "name": "title",
+            "nullable": false,
+            "type": "String",
+          },
+        },
+        "indexes": {},
+        "name": "Article",
+        "primary": "id",
+        "primaryColumn": "id",
+        "tableName": "article",
+        "unique": {},
+      },
+    },
+    "enums": {
+      "ArticleState": [
+        "draft",
+        "published",
+        "archived",
+      ],
+    },
+  },
+  "settings": {},
+  "validation": {},
+}
+`;
+
+exports[`lax schema converter many-has-many 1`] = `
+{
+  "acl": {
+    "roles": {},
+  },
+  "model": {
+    "entities": {
+      "Article": {
+        "eventLog": {
+          "enabled": true,
+        },
+        "fields": {
+          "id": {
+            "columnName": "id",
+            "columnType": "uuid",
+            "name": "id",
+            "nullable": false,
+            "type": "Uuid",
+          },
+          "tags": {
+            "inversedBy": "articles",
+            "joiningTable": {
+              "eventLog": {
+                "enabled": true,
+              },
+              "inverseJoiningColumn": {
+                "columnName": "tag_id",
+                "onDelete": "cascade",
+              },
+              "joiningColumn": {
+                "columnName": "article_id",
+                "onDelete": "cascade",
+              },
+              "tableName": "article_tags",
+            },
+            "name": "tags",
+            "target": "Tag",
+            "type": "ManyHasMany",
+          },
+          "title": {
+            "columnName": "title",
+            "columnType": "text",
+            "name": "title",
+            "nullable": false,
+            "type": "String",
+          },
+        },
+        "indexes": {},
+        "name": "Article",
+        "primary": "id",
+        "primaryColumn": "id",
+        "tableName": "article",
+        "unique": {},
+      },
+      "Tag": {
+        "eventLog": {
+          "enabled": true,
+        },
+        "fields": {
+          "articles": {
+            "name": "articles",
+            "ownedBy": "tags",
+            "target": "Article",
+            "type": "ManyHasMany",
+          },
+          "id": {
+            "columnName": "id",
+            "columnType": "uuid",
+            "name": "id",
+            "nullable": false,
+            "type": "Uuid",
+          },
+        },
+        "indexes": {},
+        "name": "Tag",
+        "primary": "id",
+        "primaryColumn": "id",
+        "tableName": "tag",
+        "unique": {},
+      },
+    },
+    "enums": {},
+  },
+  "settings": {},
+  "validation": {},
+}
+`;
+
+exports[`lax schema converter one-has-many 1`] = `
+{
+  "acl": {
+    "roles": {},
+  },
+  "model": {
+    "entities": {
+      "Article": {
+        "eventLog": {
+          "enabled": true,
+        },
+        "fields": {
+          "category": {
+            "inversedBy": "articles",
+            "joiningColumn": {
+              "columnName": "category_id",
+              "onDelete": "restrict",
+            },
+            "name": "category",
+            "nullable": true,
+            "target": "Category",
+            "type": "ManyHasOne",
+          },
+          "id": {
+            "columnName": "id",
+            "columnType": "uuid",
+            "name": "id",
+            "nullable": false,
+            "type": "Uuid",
+          },
+          "title": {
+            "columnName": "title",
+            "columnType": "text",
+            "name": "title",
+            "nullable": false,
+            "type": "String",
+          },
+        },
+        "indexes": {},
+        "name": "Article",
+        "primary": "id",
+        "primaryColumn": "id",
+        "tableName": "article",
+        "unique": {},
+      },
+      "Category": {
+        "eventLog": {
+          "enabled": true,
+        },
+        "fields": {
+          "articles": {
+            "name": "articles",
+            "ownedBy": "category",
+            "target": "Article",
+            "type": "OneHasMany",
+          },
+          "id": {
+            "columnName": "id",
+            "columnType": "uuid",
+            "name": "id",
+            "nullable": false,
+            "type": "Uuid",
+          },
+        },
+        "indexes": {},
+        "name": "Category",
+        "primary": "id",
+        "primaryColumn": "id",
+        "tableName": "category",
+        "unique": {},
+      },
+    },
+    "enums": {},
+  },
+  "settings": {},
+  "validation": {},
+}
+`;
+
+exports[`lax schema converter one-has-one 1`] = `
+{
+  "acl": {
+    "roles": {},
+  },
+  "model": {
+    "entities": {
+      "Article": {
+        "eventLog": {
+          "enabled": true,
+        },
+        "fields": {
+          "content": {
+            "inversedBy": "article",
+            "joiningColumn": {
+              "columnName": "content_id",
+              "onDelete": "restrict",
+            },
+            "name": "content",
+            "nullable": true,
+            "target": "Content",
+            "type": "OneHasOne",
+          },
+          "id": {
+            "columnName": "id",
+            "columnType": "uuid",
+            "name": "id",
+            "nullable": false,
+            "type": "Uuid",
+          },
+          "title": {
+            "columnName": "title",
+            "columnType": "text",
+            "name": "title",
+            "nullable": false,
+            "type": "String",
+          },
+        },
+        "indexes": {},
+        "name": "Article",
+        "primary": "id",
+        "primaryColumn": "id",
+        "tableName": "article",
+        "unique": {},
+      },
+      "Content": {
+        "eventLog": {
+          "enabled": true,
+        },
+        "fields": {
+          "article": {
+            "name": "article",
+            "nullable": true,
+            "ownedBy": "content",
+            "target": "Article",
+            "type": "OneHasOne",
+          },
+          "id": {
+            "columnName": "id",
+            "columnType": "uuid",
+            "name": "id",
+            "nullable": false,
+            "type": "Uuid",
+          },
+        },
+        "indexes": {},
+        "name": "Content",
+        "primary": "id",
+        "primaryColumn": "id",
+        "tableName": "content",
+        "unique": {},
+      },
+    },
+    "enums": {},
+  },
+  "settings": {},
+  "validation": {},
+}
+`;

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

@@ -0,0 +1,137 @@
+import { expect, test } from 'vitest'
+import { LaxSchemaConverter } from '../../../src'
+
+test('lax schema converter basic', () => {
+	const converter = new LaxSchemaConverter(
+		{
+			entities: {
+				Article: {
+					fields: {
+						title: { type: 'string', notNull: true },
+						content: { type: 'json' },
+						state: { type: 'enum', values: ['draft', 'published', 'archived'], enumName: 'ArticleState' },
+					},
+				},
+			},
+		},
+	)
+	expect(converter.convert()).toMatchSnapshot()
+})
+
+
+test('lax schema converter one-has-many', () => {
+	const converter = new LaxSchemaConverter(
+		{
+			entities: {
+				Article: {
+					fields: {
+						title: { type: 'string', notNull: true },
+						category: { type: 'manyHasOne', targetEntity: 'Category', targetField: 'articles' },
+					},
+				},
+				Category: {
+					fields: {
+						articles: { type: 'oneHasMany', targetEntity: 'Article', targetField: 'category' },
+					},
+				},
+			},
+		},
+	)
+	const schema1 = converter.convert()
+	expect(schema1).toMatchSnapshot()
+	const converter2 = new LaxSchemaConverter(
+		{
+			entities: {
+				Article: {
+					fields: {
+						title: { type: 'string', notNull: true },
+						category: { type: 'manyHasOne', targetEntity: 'Category', targetField: 'articles' },
+					},
+				},
+				Category: {
+					fields: {},
+				},
+			},
+		},
+	)
+	expect(converter2.convert()).deep.eq(schema1)
+})
+
+
+test('lax schema converter many-has-many', () => {
+	const converter = new LaxSchemaConverter(
+		{
+			entities: {
+				Article: {
+					fields: {
+						title: { type: 'string', notNull: true },
+						tags: { type: 'manyHasMany', targetEntity: 'Tag', targetField: 'articles' },
+					},
+				},
+				Tag: {
+					fields: {
+						articles: { type: 'manyHasManyInverse', targetEntity: 'Article', targetField: 'tags' },
+					},
+				},
+			},
+		},
+	)
+	const schema1 = converter.convert()
+	expect(schema1).toMatchSnapshot()
+	const converter2 = new LaxSchemaConverter(
+		{
+			entities: {
+				Article: {
+					fields: {
+						title: { type: 'string', notNull: true },
+						tags: { type: 'manyHasMany', targetEntity: 'Tag', targetField: 'articles' },
+					},
+				},
+				Tag: {
+					fields: {},
+				},
+			},
+		},
+	)
+	expect(converter2.convert()).deep.eq(schema1)
+})
+
+
+test('lax schema converter one-has-one', () => {
+	const converter = new LaxSchemaConverter(
+		{
+			entities: {
+				Article: {
+					fields: {
+						title: { type: 'string', notNull: true },
+						content: { type: 'oneHasOne', targetEntity: 'Content', targetField: 'article' },
+					},
+				},
+				Content: {
+					fields: {
+						article: { type: 'oneHasOneInverse', targetEntity: 'Article', targetField: 'content' },
+					},
+				},
+			},
+		},
+	)
+	const schema1 = converter.convert()
+	expect(schema1).toMatchSnapshot()
+	const converter2 = new LaxSchemaConverter(
+		{
+			entities: {
+				Article: {
+					fields: {
+						title: { type: 'string', notNull: true },
+						content: { type: 'oneHasOne', targetEntity: 'Content', targetField: 'article' },
+					},
+				},
+				Content: {
+					fields: {},
+				},
+			},
+		},
+	)
+	expect(converter2.convert()).deep.eq(schema1)
+})
+

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

@@ -159,3 +159,25 @@ test('fails on undefined variable', () => {
 		{ role: 'editor', variables: [] },
 	])
 })
+
+
+test('use fallback value', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+			editor: {
+				variables: {
+					localeID: { type: Acl.VariableType.condition, fallback: { always: true } },
+				},
+				entities: {},
+			},
+		},
+	}, [
+		{ role: 'editor', variables: [] },
+	], MembershipResolver.UnknownIdentity)
+	assert.deepStrictEqual(result.errors, [])
+
+	assert.deepStrictEqual(result.memberships, [
+		{ role: 'editor', variables: [{ name: 'localeID', condition: { always: true } }] },
+	])
+})

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

@@ -0,0 +1,143 @@
+import { assert, test } from 'vitest'
+import { Model } from '@contember/schema'
+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 = {
+		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: {},
+			},
+			FooMeta: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'FooMeta',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'foo_meta',
+				unique: {},
+				eventLog: { enabled: true },
+				indexes: {},
+			},
+			BarMeta: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'BarMeta',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'bar',
+				unique: {},
+				eventLog: { enabled: true },
+				indexes: {},
+			},
+		},
+	}
+	const validator = new ModelValidator(model)
+	assert.deepStrictEqual(validator.validate(), [
+		{
+			code: 'MODEL_NAME_COLLISION',
+			message: 'entity FooMeta collides with entity Foo, because a GraphQL type with "Meta" suffix is created for every entity',
+			path: ['entities', 'FooMeta'],
+		},
+	])
+})

package/tests/cases/unit/schemas/.eslintignore

@@ -0,0 +1 @@
+*.ts

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

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

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

@@ -0,0 +1,8 @@
+import { SchemaDefinition as def } from '@contember/schema-definition'
+
+export const articleState = def.createEnum('draft', 'published')
+
+export class Article {
+	title = def.stringColumn()
+	state = def.enumColumn(articleState).notNull().default('draft')
+}

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

@@ -0,0 +1,17 @@
+import { SchemaDefinition as def } from '@contember/schema-definition'
+
+export class Article {
+	title = def.stringColumn()
+	category = def.manyHasOne(Category, 'articles')
+	tags = def.manyHasMany(Tag, 'articles')
+}
+
+export class Category {
+	name = def.stringColumn()
+	articles = def.oneHasMany(Article, 'category')
+}
+
+export class Tag {
+	name = def.stringColumn()
+	tags = def.manyHasManyInverse(Article, 'tags')
+}

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

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

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

@@ -0,0 +1,31 @@
+import { createSchema } from '@contember/schema-definition'
+import { test, expect } 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 { readFile, writeFile } from 'fs/promises'
+import { join } from 'path'
+import { TsDefinitionGenerator } from '../../../src'
+
+
+const tests = [
+	['basic', basic],
+	['relations', relations],
+	['unique', unique],
+	['enum', enum_],
+] as const
+for (const [name, def] of tests) {
+	test(`generate schema: ${name}`, async () => {
+		const schema = createSchema(def)
+		const generator = new TsDefinitionGenerator(schema)
+		const content = await readFile(join(__dirname, `schemas/${name}.ts`), 'utf-8')
+		const generated = generator.generate()
+		try {
+			expect(generated).toBe(content)
+		} catch (e) {
+			await writeFile(join(__dirname, `schemas/${name}.actual.ts`), generated, 'utf8')
+			throw e
+		}
+	})
+}