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

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

@@ -3,20 +3,26 @@ import { MembershipResolver, MembershipValidationErrorType } from '../../../src'
 import { Acl } from '@contember/schema'
 
 const id1 = 'bff057b3-11f7-4bc7-abe3-1f2ef266824d'
+const id2 = '1cdb828f-62f0-4ae5-9b2c-e53b3e7584ef'
 test('read membership with entity variable', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {
-					localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [{ name: 'localeID', values: [id1] }] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [{ name: 'localeID', values: [id1] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 	expect(result.errors).toStrictEqual([])
 	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { in: [id1] } }] },
@@ -25,18 +31,23 @@ test('read membership with entity variable', () => {
 
 test('read fails when variable is not provided', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {
-					localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_EMPTY,
 		role: 'editor',
@@ -63,7 +74,7 @@ test('read membership with predefined variable', () => {
 		{ role: 'editor', variables: [] },
 	], {
 		identityId: id1,
-	})
+	}, false)
 	expect(result.errors).toStrictEqual([])
 	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id1] } }] },
@@ -71,39 +82,107 @@ test('read membership with predefined variable', () => {
 })
 
 test('read membership with condition variable', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						cond: { type: Acl.VariableType.condition },
+					},
+					entities: {},
+				},
+			},
+		},
+		[
+			{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify({ eq: 'foo' })] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
+		{ role: 'editor', variables: [{ name: 'cond', condition: { eq: 'foo' } }] },
+	])
+})
+
+test('fails when trying to override predefined variable with stored', () => {
 	const reader = new MembershipResolver()
 	const result = reader.resolve({
 		roles: {
 			editor: {
 				variables: {
-					cond: { type: Acl.VariableType.condition },
+					self: { type: Acl.VariableType.predefined, value: 'identityID' },
 				},
 				entities: {},
 			},
 		},
 	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify({ eq: 'foo' })] }] },
-	], MembershipResolver.UnknownIdentity)
-	expect(result.errors).toStrictEqual([])
+		{
+			role: 'editor',
+			variables: [
+				{ name: 'self', values: [id2] },
+			],
+		},
+	], {
+		identityId: id1,
+	}, false)
+	expect(result.errors).toEqual([{
+		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
+		role: 'editor',
+		variable: 'self',
+	}])
 	expect(result.memberships).toStrictEqual([
-		{ role: 'editor', variables: [{ name: 'cond', condition: { eq: 'foo' } }] },
+		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id1] } }] },
 	])
 })
 
-test('fails on invalid condition', () => {
+test('read overridden predefined variable with assume', () => {
 	const reader = new MembershipResolver()
 	const result = reader.resolve({
 		roles: {
 			editor: {
 				variables: {
-					cond: { type: Acl.VariableType.condition },
+					self: { type: Acl.VariableType.predefined, value: 'identityID' },
 				},
 				entities: {},
 			},
 		},
 	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
-	], MembershipResolver.UnknownIdentity)
+		{
+			role: 'editor',
+			variables: [
+				{ name: 'self', values: [id2] },
+			],
+		},
+	], {
+		identityId: id1,
+	}, true)
+	expect(result.errors).toEqual([])
+	expect(result.memberships).toStrictEqual([
+		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id2] } }] },
+	])
+})
+
+test('fails on invalid condition', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						cond: { type: Acl.VariableType.condition },
+					},
+					entities: {},
+				},
+			},
+		},
+		[
+			{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_INVALID,
@@ -119,13 +198,12 @@ test('fails on invalid condition', () => {
 test('fails on undefined role', () => {
 	const reader = new MembershipResolver()
 	const result = reader.resolve({
-		roles: {
-		},
+		roles: {},
 	}, [
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
 	], {
 		identityId: id1,
-	})
+	}, false)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.ROLE_NOT_FOUND,
@@ -138,16 +216,21 @@ test('fails on undefined role', () => {
 
 test('fails on undefined variable', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {},
-				entities: {},
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {},
+					entities: {},
+				},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
@@ -160,21 +243,25 @@ test('fails on undefined variable', () => {
 	])
 })
 
-
 test('use fallback value', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {
-					localeID: { type: Acl.VariableType.condition, fallback: { always: true } },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						localeID: { type: Acl.VariableType.condition, fallback: { always: true } },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 	expect(result.errors).toStrictEqual([])
 
 	expect(result.memberships).toStrictEqual([

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

@@ -1,4 +1,4 @@
-import { expect, describe, test } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import { modelSchema } from '../../../src/type-schema'
 import { Model } from '@contember/schema'
 
@@ -17,9 +17,9 @@ describe('model schema', () => {
 
 	// Array of invalid PostgreSQL data type examples
 	const invalidDataTypes = [
-		'varchar(255',           // Missing closing parenthesis
-		'character(10))',        // Extra closing parenthesis
-		'numeric(,2)',           // Missing first parameter
+		'varchar(255', // Missing closing parenthesis
+		'character(10))', // Extra closing parenthesis
+		'numeric(,2)', // Missing first parameter
 		'geometry(Point,4326))', // Extra closing parenthesis
 		'VARCHAR(255) COLLATE "de_DE" (extra text)', // Extra text outside the valid pattern
 		'VARCHAR(255) COLLATE "de_DE', // Missing closing quote

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

@@ -92,7 +92,6 @@ test('column name collision', () => {
 	])
 })
 
-
 namespace ViewRelations {
 	@c.View('SELECT 1')
 	export class Foo {

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

@@ -7,7 +7,7 @@ describe('printJsValue', () => {
 	})
 
 	test('string escape', () => {
-		expect(printJsValue('foo\'bar')).toEqual(`'foo\\'bar'`)
+		expect(printJsValue("foo'bar")).toEqual(`'foo\\'bar'`)
 	})
 
 	test('number', () => {
@@ -31,7 +31,8 @@ describe('printJsValue', () => {
 	1,
 	2,
 	3,
-]`)
+]`,
+		)
 	})
 
 	test('inline object', () => {
@@ -43,7 +44,8 @@ describe('printJsValue', () => {
 			`{
 	a: 1,
 	b: 2,
-}`)
+}`,
+		)
 	})
 
 	test('nested block object', () => {
@@ -57,16 +59,17 @@ describe('printJsValue', () => {
 			},
 		},
 	},
-}`)
+}`,
+		)
 	})
 
-
 	test('one level nested block object', () => {
 		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, (_, path) => path.length === 0)).toEqual(
 			`{
 	a: 1,
 	b: { c: { d: { e: 1 } } },
-}`)
+}`,
+		)
 	})
 
 	test('nested block object and arr', () => {
@@ -83,6 +86,7 @@ describe('printJsValue', () => {
 			6,
 		],
 	],
-}`)
+}`,
+		)
 	})
 })

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

@@ -1,4 +1,4 @@
-import { expect, test, describe } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import { conditionSchema } from '../../../src/type-schema'
 import { Model } from '@contember/schema'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
@@ -43,7 +43,6 @@ describe('where schema', () => {
 		expect(whereSchema({ schema, entity: schema.entities.Article })(where)).toStrictEqual(where)
 	})
 
-
 	test('where with relation', () => {
 		const where = {
 			tags: { name: { eq: 'xx' } },
@@ -55,35 +54,37 @@ describe('where schema', () => {
 		const where = {
 			name: { eq: 'foo' },
 		}
-		expect(() => whereSchema({
-			schema,
-			entity: schema.entities.Article,
-		})(where)).toThrow('value at root: extra property name found')
+		expect(() =>
+			whereSchema({
+				schema,
+				entity: schema.entities.Article,
+			})(where)
+		).toThrow('value at root: extra property name found')
 	})
 
-
 	test('undefined field in relation', () => {
 		const where = {
 			tags: {
 				caption: { eq: 'foo' },
-
 			},
 		}
-		expect(() => whereSchema({
-			schema,
-			entity: schema.entities.Article,
-		})(where)).toThrow('value at path /tags: extra property caption found')
+		expect(() =>
+			whereSchema({
+				schema,
+				entity: schema.entities.Article,
+			})(where)
+		).toThrow('value at path /tags: extra property caption found')
 	})
 
-
 	test('invalid condition', () => {
 		const where = {
 			title: { xx: 'foo' },
 		}
-		expect(() => whereSchema({
-			schema,
-			entity: schema.entities.Article,
-		})(where)).toThrow('value at path /title: extra property xx found')
+		expect(() =>
+			whereSchema({
+				schema,
+				entity: schema.entities.Article,
+			})(where)
+		).toThrow('value at path /title: extra property xx found')
 	})
-
 })

package/dist/development/index.cjs

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const modelUtils = require("./src/model/modelUtils.cjs");
-const resolveDefaultColumnType = require("./src/model/resolveDefaultColumnType.cjs");
-const NamingConventions = require("./src/model/NamingConventions.cjs");
-const Typesafe = require("@contember/typesafe");
-const acl = require("./src/type-schema/acl.cjs");
-require("@contember/schema");
-const model = require("./src/type-schema/model.cjs");
-const settings = require("./src/type-schema/settings.cjs");
-const validation = require("./src/type-schema/validation.cjs");
-const actions = require("./src/type-schema/actions.cjs");
-const TsDefinitionGenerator = require("./src/definition-generator/TsDefinitionGenerator.cjs");
-const AclDefinitionCodeGenerator = require("./src/definition-generator/AclDefinitionCodeGenerator.cjs");
-const DefinitionCodeGenerator = require("./src/definition-generator/DefinitionCodeGenerator.cjs");
-const DefinitionNamingConventions = require("./src/definition-generator/DefinitionNamingConventions.cjs");
-const schema = require("./src/lax/schema.cjs");
-const LaxSchemaConverter = require("./src/lax/LaxSchemaConverter.cjs");
-const AllowAllPermissionFactory = require("./src/acl/AllowAllPermissionFactory.cjs");
-const PredicateDefinitionProcessor = require("./src/acl/PredicateDefinitionProcessor.cjs");
-const schemaUtils = require("./src/acl/schemaUtils.cjs");
-const dataUtils = require("./src/dataUtils.cjs");
-const AclValidator = require("./src/validation/AclValidator.cjs");
-const ModelValidator = require("./src/validation/ModelValidator.cjs");
-const ValidationValidator = require("./src/validation/ValidationValidator.cjs");
-const errors = require("./src/validation/errors.cjs");
-const SchemaValidator = require("./src/validation/SchemaValidator.cjs");
-const MembershipResolver = require("./src/validation/MembershipResolver.cjs");
-const schemaNormalizer = require("./src/schemaNormalizer.cjs");
-const schemaFilter = require("./src/schemaFilter.cjs");
-const schemaChecksum = require("./src/schemaChecksum.cjs");
-const deepCompare = require("./src/utils/deepCompare.cjs");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const Typesafe__namespace = /* @__PURE__ */ _interopNamespaceDefault(Typesafe);
-const emptySchema = {
-  model: modelUtils.emptyModelSchema,
-  acl: { roles: {} },
-  validation: {},
-  actions: { triggers: {}, targets: {} },
-  settings: {}
-};
-const schemaType = Typesafe__namespace.object({
-  model: model.modelSchema,
-  acl: acl.aclSchema,
-  validation: validation.validationSchema,
-  actions: Typesafe__namespace.coalesce(actions.actionsSchema, { triggers: {}, targets: {} }),
-  settings: Typesafe__namespace.coalesce(settings.settingsSchema, {})
-});
-exports.ModelError = modelUtils.ModelError;
-exports.ModelErrorCode = modelUtils.ModelErrorCode;
-exports.acceptEveryFieldVisitor = modelUtils.acceptEveryFieldVisitor;
-exports.acceptFieldVisitor = modelUtils.acceptFieldVisitor;
-exports.acceptRelationTypeVisitor = modelUtils.acceptRelationTypeVisitor;
-exports.emptyModelSchema = modelUtils.emptyModelSchema;
-exports.getColumnName = modelUtils.getColumnName;
-exports.getColumnType = modelUtils.getColumnType;
-exports.getEntity = modelUtils.getEntity;
-exports.getField = modelUtils.getField;
-exports.getTargetEntity = modelUtils.getTargetEntity;
-exports.isColumn = modelUtils.isColumn;
-exports.isInverseRelation = modelUtils.isInverseRelation;
-exports.isOwningRelation = modelUtils.isOwningRelation;
-exports.isRelation = modelUtils.isRelation;
-exports.tryGetColumnName = modelUtils.tryGetColumnName;
-exports.resolveDefaultColumnType = resolveDefaultColumnType.resolveDefaultColumnType;
-exports.DefaultNamingConventions = NamingConventions.DefaultNamingConventions;
-exports.TsDefinitionGenerator = TsDefinitionGenerator.TsDefinitionGenerator;
-exports.AclDefinitionCodeGenerator = AclDefinitionCodeGenerator.AclDefinitionCodeGenerator;
-exports.DefinitionCodeGenerator = DefinitionCodeGenerator.DefinitionCodeGenerator;
-exports.DefinitionNamingConventions = DefinitionNamingConventions.DefinitionNamingConventions;
-exports.LaxSchema = schema.LaxSchema;
-exports.LaxSchemaConverter = LaxSchemaConverter.LaxSchemaConverter;
-exports.AllowAllPermissionFactory = AllowAllPermissionFactory.AllowAllPermissionFactory;
-exports.PredicateDefinitionProcessor = PredicateDefinitionProcessor.PredicateDefinitionProcessor;
-exports.getRoleVariables = schemaUtils.getRoleVariables;
-exports.NoDataError = dataUtils.NoDataError;
-exports.resolveColumnValue = dataUtils.resolveColumnValue;
-exports.resolveDefaultValue = dataUtils.resolveDefaultValue;
-exports.AclValidator = AclValidator.AclValidator;
-exports.ModelValidator = ModelValidator.ModelValidator;
-exports.ValidationValidator = ValidationValidator.ValidationValidator;
-exports.ErrorBuilder = errors.ErrorBuilder;
-exports.SchemaValidator = SchemaValidator.SchemaValidator;
-exports.MembershipReadResult = MembershipResolver.MembershipReadResult;
-exports.MembershipResolver = MembershipResolver.MembershipResolver;
-exports.MembershipValidationError = MembershipResolver.MembershipValidationError;
-exports.MembershipValidationErrorType = MembershipResolver.MembershipValidationErrorType;
-exports.normalizeSchema = schemaNormalizer.normalizeSchema;
-exports.filterSchemaByStage = schemaFilter.filterSchemaByStage;
-exports.calculateSchemaChecksum = schemaChecksum.calculateSchemaChecksum;
-exports.compareArraysIgnoreOrder = deepCompare.compareArraysIgnoreOrder;
-exports.deepCompare = deepCompare.deepCompare;
-exports.emptySchema = emptySchema;
-exports.schemaType = schemaType;
-//# sourceMappingURL=index.cjs.map

package/dist/development/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":["../../../packages/schema-utils/src/index.ts"],"sourcesContent":["import { Schema } from '@contember/schema'\nimport { emptyModelSchema } from './model'\nimport * as Typesafe from '@contember/typesafe'\nimport { aclSchema, modelSchema, validationSchema, settingsSchema } from './type-schema'\nimport { actionsSchema } from './type-schema/actions'\n\nexport * from './definition-generator'\nexport * from './lax'\nexport * from './model'\nexport * from './acl'\nexport * from './dataUtils'\nexport * from './validation'\nexport * from './schemaNormalizer'\nexport * from './schemaFilter'\nexport * from './schemaChecksum'\nexport { deepCompare, compareArraysIgnoreOrder } from './utils'\n\nexport const emptySchema: Schema = {\n\tmodel: emptyModelSchema,\n\tacl: { roles: {} },\n\tvalidation: {},\n\tactions: { triggers: {}, targets: {} },\n\tsettings: {},\n}\n\nexport const schemaType: Typesafe.Type<Schema> = Typesafe.object({\n\tmodel: modelSchema,\n\tacl: aclSchema,\n\tvalidation: validationSchema,\n\tactions: Typesafe.coalesce(actionsSchema, { triggers: {}, targets: {} }),\n\tsettings: Typesafe.coalesce(settingsSchema, {}),\n})\n"],"names":["emptyModelSchema","Typesafe","modelSchema","aclSchema","validationSchema","actionsSchema","settingsSchema"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBO,MAAM,cAAsB;AAAA,EAClC,OAAOA,WAAA;AAAA,EACP,KAAK,EAAE,OAAO,GAAG;AAAA,EACjB,YAAY,CAAC;AAAA,EACb,SAAS,EAAE,UAAU,IAAI,SAAS,CAAA,EAAG;AAAA,EACrC,UAAU,CAAA;AACX;AAEa,MAAA,aAAoCC,oBAAS,OAAO;AAAA,EAChE,OAAOC,MAAA;AAAA,EACP,KAAKC,IAAA;AAAA,EACL,YAAYC,WAAA;AAAA,EACZ,SAASH,oBAAS,SAASI,QAAe,eAAA,EAAE,UAAU,CAAI,GAAA,SAAS,CAAA,GAAI;AAAA,EACvE,UAAUJ,oBAAS,SAASK,SAAAA,gBAAgB,CAAE,CAAA;AAC/C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/development/index.js

@@ -1,94 +0,0 @@
-import { emptyModelSchema } from "./src/model/modelUtils.js";
-import { ModelError, ModelErrorCode, acceptEveryFieldVisitor, acceptFieldVisitor, acceptRelationTypeVisitor, getColumnName, getColumnType, getEntity, getField, getTargetEntity, isColumn, isInverseRelation, isOwningRelation, isRelation, tryGetColumnName } from "./src/model/modelUtils.js";
-import { resolveDefaultColumnType } from "./src/model/resolveDefaultColumnType.js";
-import { DefaultNamingConventions } from "./src/model/NamingConventions.js";
-import * as Typesafe from "@contember/typesafe";
-import { aclSchema } from "./src/type-schema/acl.js";
-import "@contember/schema";
-import { modelSchema } from "./src/type-schema/model.js";
-import { settingsSchema } from "./src/type-schema/settings.js";
-import { validationSchema } from "./src/type-schema/validation.js";
-import { actionsSchema } from "./src/type-schema/actions.js";
-import { TsDefinitionGenerator } from "./src/definition-generator/TsDefinitionGenerator.js";
-import { AclDefinitionCodeGenerator } from "./src/definition-generator/AclDefinitionCodeGenerator.js";
-import { DefinitionCodeGenerator } from "./src/definition-generator/DefinitionCodeGenerator.js";
-import { DefinitionNamingConventions } from "./src/definition-generator/DefinitionNamingConventions.js";
-import { LaxSchema } from "./src/lax/schema.js";
-import { LaxSchemaConverter } from "./src/lax/LaxSchemaConverter.js";
-import { AllowAllPermissionFactory } from "./src/acl/AllowAllPermissionFactory.js";
-import { PredicateDefinitionProcessor } from "./src/acl/PredicateDefinitionProcessor.js";
-import { getRoleVariables } from "./src/acl/schemaUtils.js";
-import { NoDataError, resolveColumnValue, resolveDefaultValue } from "./src/dataUtils.js";
-import { AclValidator } from "./src/validation/AclValidator.js";
-import { ModelValidator } from "./src/validation/ModelValidator.js";
-import { ValidationValidator } from "./src/validation/ValidationValidator.js";
-import { ErrorBuilder } from "./src/validation/errors.js";
-import { SchemaValidator } from "./src/validation/SchemaValidator.js";
-import { MembershipReadResult, MembershipResolver, MembershipValidationError, MembershipValidationErrorType } from "./src/validation/MembershipResolver.js";
-import { normalizeSchema } from "./src/schemaNormalizer.js";
-import { filterSchemaByStage } from "./src/schemaFilter.js";
-import { calculateSchemaChecksum } from "./src/schemaChecksum.js";
-import { compareArraysIgnoreOrder, deepCompare } from "./src/utils/deepCompare.js";
-const emptySchema = {
-  model: emptyModelSchema,
-  acl: { roles: {} },
-  validation: {},
-  actions: { triggers: {}, targets: {} },
-  settings: {}
-};
-const schemaType = Typesafe.object({
-  model: modelSchema,
-  acl: aclSchema,
-  validation: validationSchema,
-  actions: Typesafe.coalesce(actionsSchema, { triggers: {}, targets: {} }),
-  settings: Typesafe.coalesce(settingsSchema, {})
-});
-export {
-  AclDefinitionCodeGenerator,
-  AclValidator,
-  AllowAllPermissionFactory,
-  DefaultNamingConventions,
-  DefinitionCodeGenerator,
-  DefinitionNamingConventions,
-  ErrorBuilder,
-  LaxSchema,
-  LaxSchemaConverter,
-  MembershipReadResult,
-  MembershipResolver,
-  MembershipValidationError,
-  MembershipValidationErrorType,
-  ModelError,
-  ModelErrorCode,
-  ModelValidator,
-  NoDataError,
-  PredicateDefinitionProcessor,
-  SchemaValidator,
-  TsDefinitionGenerator,
-  ValidationValidator,
-  acceptEveryFieldVisitor,
-  acceptFieldVisitor,
-  acceptRelationTypeVisitor,
-  calculateSchemaChecksum,
-  compareArraysIgnoreOrder,
-  deepCompare,
-  emptyModelSchema,
-  emptySchema,
-  filterSchemaByStage,
-  getColumnName,
-  getColumnType,
-  getEntity,
-  getField,
-  getRoleVariables,
-  getTargetEntity,
-  isColumn,
-  isInverseRelation,
-  isOwningRelation,
-  isRelation,
-  normalizeSchema,
-  resolveColumnValue,
-  resolveDefaultColumnType,
-  resolveDefaultValue,
-  schemaType,
-  tryGetColumnName
-};
-//# sourceMappingURL=index.js.map

package/dist/development/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../packages/schema-utils/src/index.ts"],"sourcesContent":["import { Schema } from '@contember/schema'\nimport { emptyModelSchema } from './model'\nimport * as Typesafe from '@contember/typesafe'\nimport { aclSchema, modelSchema, validationSchema, settingsSchema } from './type-schema'\nimport { actionsSchema } from './type-schema/actions'\n\nexport * from './definition-generator'\nexport * from './lax'\nexport * from './model'\nexport * from './acl'\nexport * from './dataUtils'\nexport * from './validation'\nexport * from './schemaNormalizer'\nexport * from './schemaFilter'\nexport * from './schemaChecksum'\nexport { deepCompare, compareArraysIgnoreOrder } from './utils'\n\nexport const emptySchema: Schema = {\n\tmodel: emptyModelSchema,\n\tacl: { roles: {} },\n\tvalidation: {},\n\tactions: { triggers: {}, targets: {} },\n\tsettings: {},\n}\n\nexport const schemaType: Typesafe.Type<Schema> = Typesafe.object({\n\tmodel: modelSchema,\n\tacl: aclSchema,\n\tvalidation: validationSchema,\n\tactions: Typesafe.coalesce(actionsSchema, { triggers: {}, targets: {} }),\n\tsettings: Typesafe.coalesce(settingsSchema, {}),\n})\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBO,MAAM,cAAsB;AAAA,EAClC,OAAO;AAAA,EACP,KAAK,EAAE,OAAO,GAAG;AAAA,EACjB,YAAY,CAAC;AAAA,EACb,SAAS,EAAE,UAAU,IAAI,SAAS,CAAA,EAAG;AAAA,EACrC,UAAU,CAAA;AACX;AAEa,MAAA,aAAoC,SAAS,OAAO;AAAA,EAChE,OAAO;AAAA,EACP,KAAK;AAAA,EACL,YAAY;AAAA,EACZ,SAAS,SAAS,SAAS,eAAe,EAAE,UAAU,CAAI,GAAA,SAAS,CAAA,GAAI;AAAA,EACvE,UAAU,SAAS,SAAS,gBAAgB,CAAE,CAAA;AAC/C,CAAC;"}