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

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

@@ -1,6 +1,6 @@
 import { expect, test } from 'bun:test'
 import { c, createSchema } from '../../../src'
-import { Acl } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 
 namespace SimpleModel {
 	export const publicRole = c.createRole('public')
@@ -23,7 +23,6 @@ test('simple definitions', () => {
 	})
 })
 
-
 namespace RoleOptions {
 	export const publicRole = c.createRole('public', {
 		debug: true,
@@ -46,7 +45,6 @@ test('role options', () => {
 	})
 })
 
-
 namespace ModelWithPredicate {
 	export const publicRole = c.createRole('public')
 
@@ -110,7 +108,6 @@ test('definition with a predicate on field', () => {
 	})
 })
 
-
 namespace ModelWithModificationAcl {
 	export const publicRole = c.createRole('public')
 
@@ -130,29 +127,28 @@ test('definition with update, create, delete predicates', () => {
 	const schema = createSchema(ModelWithModificationAcl)
 	expect(schema.acl.roles.public.entities.Book).toStrictEqual(
 		{
-		  'operations': {
-		    'create': {
-		      'isPublished': 'isPublished_eq_true',
-		      'title': 'isPublished_eq_true',
-		    },
-		    'delete': 'isPublished_eq_true',
-		    'update': {
-		      'isPublished': 'isPublished_eq_true',
-		      'title': 'isPublished_eq_true',
-		    },
-		  },
-		  'predicates': {
-		    'isPublished_eq_true': {
-		      'isPublished': {
-		        'eq': true,
-		      },
-		    },
-		  },
+			'operations': {
+				'create': {
+					'isPublished': 'isPublished_eq_true',
+					'title': 'isPublished_eq_true',
+				},
+				'delete': 'isPublished_eq_true',
+				'update': {
+					'isPublished': 'isPublished_eq_true',
+					'title': 'isPublished_eq_true',
+				},
+			},
+			'predicates': {
+				'isPublished_eq_true': {
+					'isPublished': {
+						'eq': true,
+					},
+				},
+			},
 		},
 	)
 })
 
-
 namespace ModelWithMultiplePredicates {
 	export const publicRole = c.createRole('public')
 
@@ -174,32 +170,31 @@ test('definition with multiple predicates on a single field', () => {
 	const schema = createSchema(ModelWithMultiplePredicates)
 	expect(schema.acl.roles.public.entities.Book).toStrictEqual(
 		{
-		  'operations': {
-		    'read': {
-		      'title': 'or_isPublished_eq_false_isPub',
-		    },
-		  },
-		  'predicates': {
-		    'or_isPublished_eq_false_isPub': {
-		      'or': [
-		        {
-		          'isPublished': {
-		            'eq': false,
-		          },
-		        },
-		        {
-		          'isPublished': {
-		            'eq': true,
-		          },
-		        },
-		      ],
-		    },
-		  },
+			'operations': {
+				'read': {
+					'title': 'or_isPublished_eq_false_isPub',
+				},
+			},
+			'predicates': {
+				'or_isPublished_eq_false_isPub': {
+					'or': [
+						{
+							'isPublished': {
+								'eq': false,
+							},
+						},
+						{
+							'isPublished': {
+								'eq': true,
+							},
+						},
+					],
+				},
+			},
 		},
 	)
 })
 
-
 namespace ModelWithJoinedPredicateCollision {
 	export const publicRole = c.createRole('public')
 
@@ -225,47 +220,46 @@ test('definition with collision', () => {
 	const schema = createSchema(ModelWithJoinedPredicateCollision)
 	expect(schema.acl.roles.public.entities.Book).toStrictEqual(
 		{
-		  '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,
-		          },
-		        },
-		      ],
-		    },
-		  },
+			'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 = c.createRole('public')
 	export const adminRole = c.createRole('admin')
@@ -283,34 +277,34 @@ test('definition with multiple roles in single predicate', () => {
 	const schema = createSchema(ModelWithMultipleRolesForSinglePredicate)
 	expect(schema.acl.roles).toStrictEqual(
 		{
-		  'admin': {
-		    'entities': {
-		      'Book': {
-		        'operations': {
-		          'read': {
-		            'title': true,
-		          },
-		        },
-		        'predicates': {},
-		      },
-		    },
-		    'stages': '*',
-		    'variables': {},
-		  },
-		  'public': {
-		    'entities': {
-		      'Book': {
-		        'operations': {
-		          'read': {
-		            'title': true,
-		          },
-		        },
-		        'predicates': {},
-		      },
-		    },
-		    'stages': '*',
-		    'variables': {},
-		  },
+			'admin': {
+				'entities': {
+					'Book': {
+						'operations': {
+							'read': {
+								'title': true,
+							},
+						},
+						'predicates': {},
+					},
+				},
+				'stages': '*',
+				'variables': {},
+			},
+			'public': {
+				'entities': {
+					'Book': {
+						'operations': {
+							'read': {
+								'title': true,
+							},
+						},
+						'predicates': {},
+					},
+				},
+				'stages': '*',
+				'variables': {},
+			},
 		},
 	)
 })
@@ -326,6 +320,7 @@ namespace ModelWithAclPredicateReferences {
 		title = c.stringColumn()
 		isPublished = c.boolColumn()
 	}
+
 	@c.Allow(publicRole, {
 		when: { book: c.canRead('title') },
 		read: ['content'],
@@ -340,41 +335,40 @@ test('definition with predicate references', () => {
 	const schema = createSchema(ModelWithAclPredicateReferences)
 	expect(schema.acl.roles.public.entities).toStrictEqual(
 		{
-		  'Book': {
-		    'operations': {
-		      'read': {
-		        'title': 'isPublished_eq_true',
-		      },
-		    },
-		    'predicates': {
-		      'isPublished_eq_true': {
-		        'isPublished': {
-		          'eq': true,
-		        },
-		      },
-		    },
-		  },
-		  'BookReview': {
-		    'operations': {
-		      'read': {
-		        'content': 'book_isPublished_eq_true',
-		      },
-		    },
-		    'predicates': {
-		      'book_isPublished_eq_true': {
-		        'book': {
-		          'isPublished': {
-		            'eq': true,
-		          },
-		        },
-		      },
-		    },
-		  },
+			'Book': {
+				'operations': {
+					'read': {
+						'title': 'isPublished_eq_true',
+					},
+				},
+				'predicates': {
+					'isPublished_eq_true': {
+						'isPublished': {
+							'eq': true,
+						},
+					},
+				},
+			},
+			'BookReview': {
+				'operations': {
+					'read': {
+						'content': 'book_isPublished_eq_true',
+					},
+				},
+				'predicates': {
+					'book_isPublished_eq_true': {
+						'book': {
+							'isPublished': {
+								'eq': true,
+							},
+						},
+					},
+				},
+			},
 		},
 	)
 })
 
-
 namespace ModelWithVariables {
 	export const managerRole = c.createRole('manager')
 	export const bookIdVariable = c.createEntityVariable('bookId', 'Book', managerRole)
@@ -392,27 +386,27 @@ test('definition with variables', () => {
 	const schema = createSchema(ModelWithVariables)
 	expect(schema.acl.roles.manager).toStrictEqual(
 		{
-		  'entities': {
-		    'Book': {
-		      'operations': {
-		        'read': {
-		          'title': 'id_bookId',
-		        },
-		      },
-		      'predicates': {
-		        'id_bookId': {
-		          'id': 'bookId',
-		        },
-		      },
-		    },
-		  },
-		  'stages': '*',
-		  'variables': {
-		    'bookId': {
-		      'entityName': 'Book',
-		      'type': Acl.VariableType.entity,
-		    },
-		  },
+			'entities': {
+				'Book': {
+					'operations': {
+						'read': {
+							'title': 'id_bookId',
+						},
+					},
+					'predicates': {
+						'id_bookId': {
+							'id': 'bookId',
+						},
+					},
+				},
+			},
+			'stages': '*',
+			'variables': {
+				'bookId': {
+					'entityName': 'Book',
+					'type': Acl.VariableType.entity,
+				},
+			},
 		},
 	)
 })
@@ -430,10 +424,10 @@ test('allow custom primary', () => {
 	const schema = createSchema(ModelWithAllowCustomPrimary)
 	expect(schema.acl.roles.public.entities.Book).toStrictEqual(
 		{
-		  'operations': {
-		    'customPrimary': true,
-		  },
-		  'predicates': {},
+			'operations': {
+				'customPrimary': true,
+			},
+			'predicates': {},
 		},
 	)
 })
@@ -451,15 +445,14 @@ test('allow custom primary', () => {
 	const schema = createSchema(ModelWithAllowCustomPrimaryAllRoles)
 	expect(schema.acl.roles.public.entities.Book).toStrictEqual(
 		{
-		  'operations': {
-		    'customPrimary': true,
-		  },
-		  'predicates': {},
+			'operations': {
+				'customPrimary': true,
+			},
+			'predicates': {},
 		},
 	)
 })
 
-
 namespace ModelWithInvalidAclPredicateReferences {
 	export const publicRole = c.createRole('public')
 
@@ -484,12 +477,11 @@ namespace ModelWithInvalidAclPredicateReferences {
 
 test('definition with invalid predicate references', () => {
 	expect(() => createSchema(ModelWithInvalidAclPredicateReferences)).toThrow(
-		'Predicate references are allowed only on relations. \n' +
-		'You cannot use "canRead("title")" on a column "content" of entity "BookReview".',
+		'Predicate references are allowed only on relations. \n'
+			+ 'You cannot use "canRead("title")" on a column "content" of entity "BookReview".',
 	)
 })
 
-
 namespace ModelWithPredefinedVariables {
 	export const customerRole = c.createRole('customer')
 	export const personId = c.createPredefinedVariable('person', 'personID', customerRole)
@@ -545,7 +537,6 @@ test('invalid column', () => {
 	expect(() => createSchema(InvalidModel)).toThrow('Field "bar" does not exist on entity "Book" in read ACL definition.')
 })
 
-
 namespace ExplicitIdPredicate {
 	export const publicRole = c.createRole('public')
 
@@ -620,7 +611,6 @@ test('no root - valid', () => {
 	})
 })
 
-
 namespace NoRootInvalid {
 	export const publicRole = c.createRole('public')
 
@@ -642,3 +632,28 @@ namespace NoRootInvalid {
 test('no root - invalid combo', () => {
 	expect(() => createSchema(NoRootInvalid)).toThrow('Operation update cannot be both allowed and disallowed on root on entity Book')
 })
+
+namespace AllowFactoryModel {
+	export const publicRole = c.createRole('public')
+
+	@c.Allow(publicRole, ({ except }) => ({
+		read: except('confidential'),
+	}))
+	export class Book {
+		title = c.stringColumn()
+		confidential = c.stringColumn()
+	}
+}
+
+test('allow with factory', () => {
+	const schema = createSchema(AllowFactoryModel)
+	expect(schema.acl.roles.public.entities.Book).toStrictEqual({
+		'operations': {
+			'read': {
+				'id': true,
+				'title': true,
+			},
+		},
+		'predicates': {},
+	})
+})

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

@@ -3,7 +3,6 @@ import { expect, test } from 'bun:test'
 import { createActions } from '../../../src/actions/definition'
 
 namespace SimpleActions {
-
 	@c.Watch({
 		name: 'book_watch',
 		watch: `
@@ -32,7 +31,6 @@ namespace SimpleActions {
 		locale = c.manyHasOne(Locale)
 	}
 
-
 	export class Category {
 		locales = c.oneHasMany(CategoryLocale, 'category')
 	}

package/dist/development/index.cjs

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("./src/acl/definition/index.cjs");
-const index$1 = require("./src/actions/definition/index.cjs");
-const index$3 = require("./src/validation/index.cjs");
-const SchemaBuilder = require("./src/model/builder/SchemaBuilder.cjs");
-const ColumnBuilder = require("./src/model/builder/ColumnBuilder.cjs");
-const ManyHasManyBuilder = require("./src/model/builder/ManyHasManyBuilder.cjs");
-const OneHasManyBuilder = require("./src/model/builder/OneHasManyBuilder.cjs");
-const ManyHasOneBuilder = require("./src/model/builder/ManyHasOneBuilder.cjs");
-const OneHasOneBuilder = require("./src/model/builder/OneHasOneBuilder.cjs");
-const FieldBuilder = require("./src/model/builder/FieldBuilder.cjs");
-const index$2 = require("./src/model/definition/index.cjs");
-const createSchema = require("./src/createSchema.cjs");
-const schemaUtils = require("@contember/schema-utils");
-const PermissionsBuilder = require("./src/acl/builder/PermissionsBuilder.cjs");
-const presets = require("./src/presets.cjs");
-const customPrimary = require("./src/acl/definition/customPrimary.cjs");
-const permissions = require("./src/acl/definition/permissions.cjs");
-const roles = require("./src/acl/definition/roles.cjs");
-const variables = require("./src/acl/definition/variables.cjs");
-const references = require("./src/acl/definition/references.cjs");
-const triggers = require("./src/actions/definition/triggers.cjs");
-const targets = require("./src/actions/definition/targets.cjs");
-const extensions = require("./src/model/definition/extensions.cjs");
-const IndexDefinition = require("./src/model/definition/IndexDefinition.cjs");
-const UniqueDefinition = require("./src/model/definition/UniqueDefinition.cjs");
-const ViewDefinition = require("./src/model/definition/ViewDefinition.cjs");
-const EventLogDefinition = require("./src/model/definition/EventLogDefinition.cjs");
-const OrderByDefinition = require("./src/model/definition/OrderByDefinition.cjs");
-const ColumnDefinition = require("./src/model/definition/fieldDefinitions/ColumnDefinition.cjs");
-const ManyHasManyDefinition = require("./src/model/definition/fieldDefinitions/ManyHasManyDefinition.cjs");
-const ManyHasManyInverseDefinition = require("./src/model/definition/fieldDefinitions/ManyHasManyInverseDefinition.cjs");
-const ManyHasOneDefinition = require("./src/model/definition/fieldDefinitions/ManyHasOneDefinition.cjs");
-const OneHasOneDefinition = require("./src/model/definition/fieldDefinitions/OneHasOneDefinition.cjs");
-const OneHasOneInverseDefinition = require("./src/model/definition/fieldDefinitions/OneHasOneInverseDefinition.cjs");
-const OneHasManyDefinition = require("./src/model/definition/fieldDefinitions/OneHasManyDefinition.cjs");
-const EnumDefinition = require("./src/model/definition/EnumDefinition.cjs");
-const c = {
-  // ACL
-  // ACL entity decorators
-  AllowCustomPrimary: customPrimary.allowCustomPrimary,
-  Allow: permissions.allow,
-  // ACL factories
-  createRole: roles.createRole,
-  createConditionVariable: variables.createConditionVariable,
-  createEntityVariable: variables.createEntityVariable,
-  createPredefinedVariable: variables.createPredefinedVariable,
-  // ACL utilities
-  canCreate: references.canCreate,
-  canRead: references.canRead,
-  canUpdate: references.canUpdate,
-  canDelete: references.canDelete,
-  // Actions
-  // Actions entity decorators
-  Watch: triggers.watch,
-  Trigger: triggers.trigger,
-  // Actions factories
-  createActionsTarget: targets.createTarget,
-  // Model
-  // Model entity decorators
-  ExtendEntity: extensions.extendEntity,
-  Index: IndexDefinition.Index,
-  Unique: UniqueDefinition.Unique,
-  View: ViewDefinition.View,
-  DisableEventLog: EventLogDefinition.DisableEventLog,
-  OrderBy: OrderByDefinition.OrderBy,
-  // Model field factories
-  column: ColumnDefinition.column,
-  boolColumn: ColumnDefinition.boolColumn,
-  intColumn: ColumnDefinition.intColumn,
-  doubleColumn: ColumnDefinition.doubleColumn,
-  dateColumn: ColumnDefinition.dateColumn,
-  timeColumn: ColumnDefinition.timeColumn,
-  dateTimeColumn: ColumnDefinition.dateTimeColumn,
-  jsonColumn: ColumnDefinition.jsonColumn,
-  stringColumn: ColumnDefinition.stringColumn,
-  enumColumn: ColumnDefinition.enumColumn,
-  uuidColumn: ColumnDefinition.uuidColumn,
-  manyHasMany: ManyHasManyDefinition.manyHasMany,
-  manyHasManyInverse: ManyHasManyInverseDefinition.manyHasManyInverse,
-  manyHasOne: ManyHasOneDefinition.manyHasOne,
-  oneHasOne: OneHasOneDefinition.oneHasOne,
-  oneHasOneInverse: OneHasOneInverseDefinition.oneHasOneInverse,
-  oneHasMany: OneHasManyDefinition.oneHasMany,
-  // Model factories
-  createEnum: EnumDefinition.createEnum,
-  // Validation
-  // Validation field decorators
-  Assert: index$3.assert,
-  Required: index$3.required,
-  AssertDefined: index$3.assertDefined,
-  AssertNotEmpty: index$3.assertNotEmpty,
-  AssertPattern: index$3.assertPattern,
-  AssertMinLength: index$3.assertMinLength,
-  AssertMaxLength: index$3.assertMaxLength,
-  ValidateWhen: index$3.when,
-  // Validation utilities
-  rules: index$3.rules
-};
-exports.AclDefinition = index;
-exports.ActionsDefinition = index$1;
-exports.InputValidation = index$3;
-exports.SchemaBuilder = SchemaBuilder.default;
-exports.ColumnBuilder = ColumnBuilder;
-exports.ManyHasManyBuilder = ManyHasManyBuilder;
-exports.OneHasManyBuilder = OneHasManyBuilder;
-exports.ManyHasOneBuilder = ManyHasOneBuilder;
-exports.OneHasOneBuilder = OneHasOneBuilder;
-exports.FieldBuilder = FieldBuilder;
-exports.SchemaDefinition = index$2;
-exports.createSchema = createSchema.createSchema;
-Object.defineProperty(exports, "AllowAllPermissionFactory", {
-  enumerable: true,
-  get: () => schemaUtils.AllowAllPermissionFactory
-});
-Object.defineProperty(exports, "PermissionsBuilder", {
-  enumerable: true,
-  get: () => PermissionsBuilder.PermissionsBuilder
-});
-exports.settingsPresets = presets.settingsPresets;
-exports.c = c;
-//# sourceMappingURL=index.cjs.map

package/dist/development/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":["../../../packages/schema-definition/src/index.ts"],"sourcesContent":["import * as AclDefinition from './acl/definition'\nimport { Role } from './acl/definition'\nimport * as ActionsDefinition from './actions/definition'\nimport * as InputValidation from './validation'\nimport { SchemaDefinition } from './model'\nimport { createSchema } from './createSchema'\n\nexport { AllowAllPermissionFactory } from '@contember/schema-utils'\nexport { PermissionsBuilder } from './acl/builder/PermissionsBuilder'\nexport * from './model'\nexport * from './presets'\n\nexport type { Role }\nexport type { VariableDefinition } from './acl/definition'\nexport type {\n\tColumnDefinition,\n\tFieldDefinition,\n\tOneHasOneDefinition,\n\tOneHasOneInverseDefinition,\n\tOneHasManyDefinition,\n\tManyHasOneDefinition,\n\tManyHasManyDefinition,\n\tManyHasManyInverseDefinition,\n\tEnumDefinition,\n} from './model/definition'\n\nexport { AclDefinition, ActionsDefinition, SchemaDefinition, InputValidation, createSchema }\n\nexport const c = {\n\n\t// ACL\n\t// ACL entity decorators\n\tAllowCustomPrimary: AclDefinition.allowCustomPrimary,\n\tAllow: AclDefinition.allow,\n\t// ACL factories\n\tcreateRole: AclDefinition.createRole,\n\tcreateConditionVariable: AclDefinition.createConditionVariable,\n\tcreateEntityVariable: AclDefinition.createEntityVariable,\n\tcreatePredefinedVariable: AclDefinition.createPredefinedVariable,\n\t// ACL utilities\n\tcanCreate: AclDefinition.canCreate,\n\tcanRead: AclDefinition.canRead,\n\tcanUpdate: AclDefinition.canUpdate,\n\tcanDelete: AclDefinition.canDelete,\n\n\n\t// Actions\n\t// Actions entity decorators\n\tWatch: ActionsDefinition.watch,\n\tTrigger: ActionsDefinition.trigger,\n\t// Actions factories\n\tcreateActionsTarget: ActionsDefinition.createTarget,\n\n\n\t// Model\n\t// Model entity decorators\n\tExtendEntity: SchemaDefinition.extendEntity,\n\tIndex: SchemaDefinition.Index,\n\tUnique: SchemaDefinition.Unique,\n\tView: SchemaDefinition.View,\n\tDisableEventLog: SchemaDefinition.DisableEventLog,\n\tOrderBy: SchemaDefinition.OrderBy,\n\t// Model field factories\n\tcolumn: SchemaDefinition.column,\n\tboolColumn: SchemaDefinition.boolColumn,\n\tintColumn: SchemaDefinition.intColumn,\n\tdoubleColumn: SchemaDefinition.doubleColumn,\n\tdateColumn: SchemaDefinition.dateColumn,\n\ttimeColumn: SchemaDefinition.timeColumn,\n\tdateTimeColumn: SchemaDefinition.dateTimeColumn,\n\tjsonColumn: SchemaDefinition.jsonColumn,\n\tstringColumn: SchemaDefinition.stringColumn,\n\tenumColumn: SchemaDefinition.enumColumn,\n\tuuidColumn: SchemaDefinition.uuidColumn,\n\tmanyHasMany: SchemaDefinition.manyHasMany,\n\tmanyHasManyInverse: SchemaDefinition.manyHasManyInverse,\n\tmanyHasOne: SchemaDefinition.manyHasOne,\n\toneHasOne: SchemaDefinition.oneHasOne,\n\toneHasOneInverse: SchemaDefinition.oneHasOneInverse,\n\toneHasMany: SchemaDefinition.oneHasMany,\n\t// Model factories\n\tcreateEnum: SchemaDefinition.createEnum,\n\n\n\t// Validation\n\t// Validation field decorators\n\tAssert: InputValidation.assert,\n\tRequired: InputValidation.required,\n\tAssertDefined: InputValidation.assertDefined,\n\tAssertNotEmpty: InputValidation.assertNotEmpty,\n\tAssertPattern: InputValidation.assertPattern,\n\tAssertMinLength: InputValidation.assertMinLength,\n\tAssertMaxLength: InputValidation.assertMaxLength,\n\tValidateWhen: InputValidation.when,\n\t// Validation utilities\n\trules: InputValidation.rules,\n\n}\n"],"names":["AclDefinition.allowCustomPrimary","AclDefinition.allow","AclDefinition.createRole","AclDefinition.createConditionVariable","AclDefinition.createEntityVariable","AclDefinition.createPredefinedVariable","AclDefinition.canCreate","AclDefinition.canRead","AclDefinition.canUpdate","AclDefinition.canDelete","ActionsDefinition.watch","ActionsDefinition.trigger","ActionsDefinition.createTarget","SchemaDefinition.extendEntity","SchemaDefinition.Index","SchemaDefinition.Unique","SchemaDefinition.View","SchemaDefinition.DisableEventLog","SchemaDefinition.OrderBy","SchemaDefinition.column","SchemaDefinition.boolColumn","SchemaDefinition.intColumn","SchemaDefinition.doubleColumn","SchemaDefinition.dateColumn","SchemaDefinition.timeColumn","SchemaDefinition.dateTimeColumn","SchemaDefinition.jsonColumn","SchemaDefinition.stringColumn","SchemaDefinition.enumColumn","SchemaDefinition.uuidColumn","SchemaDefinition.manyHasMany","SchemaDefinition.manyHasManyInverse","SchemaDefinition.manyHasOne","SchemaDefinition.oneHasOne","SchemaDefinition.oneHasOneInverse","SchemaDefinition.oneHasMany","SchemaDefinition.createEnum","InputValidation.assert","InputValidation.required","InputValidation.assertDefined","InputValidation.assertNotEmpty","InputValidation.assertPattern","InputValidation.assertMinLength","InputValidation.assertMaxLength","InputValidation.when","InputValidation.rules"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BO,MAAM,IAAI;AAAA;AAAA;AAAA,EAIhB,oBAAoBA,cAAc;AAAA,EAClC,OAAOC,YAAc;AAAA;AAAA,EAErB,YAAYC,MAAc;AAAA,EAC1B,yBAAyBC,UAAc;AAAA,EACvC,sBAAsBC,UAAc;AAAA,EACpC,0BAA0BC,UAAc;AAAA;AAAA,EAExC,WAAWC,WAAc;AAAA,EACzB,SAASC,WAAc;AAAA,EACvB,WAAWC,WAAc;AAAA,EACzB,WAAWC,WAAc;AAAA;AAAA;AAAA,EAKzB,OAAOC,SAAkB;AAAA,EACzB,SAASC,SAAkB;AAAA;AAAA,EAE3B,qBAAqBC,QAAkB;AAAA;AAAA;AAAA,EAKvC,cAAcC,WAAiB;AAAA,EAC/B,OAAOC,gBAAiB;AAAA,EACxB,QAAQC,iBAAiB;AAAA,EACzB,MAAMC,eAAiB;AAAA,EACvB,iBAAiBC,mBAAiB;AAAA,EAClC,SAASC,kBAAiB;AAAA;AAAA,EAE1B,QAAQC,iBAAiB;AAAA,EACzB,YAAYC,iBAAiB;AAAA,EAC7B,WAAWC,iBAAiB;AAAA,EAC5B,cAAcC,iBAAiB;AAAA,EAC/B,YAAYC,iBAAiB;AAAA,EAC7B,YAAYC,iBAAiB;AAAA,EAC7B,gBAAgBC,iBAAiB;AAAA,EACjC,YAAYC,iBAAiB;AAAA,EAC7B,cAAcC,iBAAiB;AAAA,EAC/B,YAAYC,iBAAiB;AAAA,EAC7B,YAAYC,iBAAiB;AAAA,EAC7B,aAAaC,sBAAiB;AAAA,EAC9B,oBAAoBC,6BAAiB;AAAA,EACrC,YAAYC,qBAAiB;AAAA,EAC7B,WAAWC,oBAAiB;AAAA,EAC5B,kBAAkBC,2BAAiB;AAAA,EACnC,YAAYC,qBAAiB;AAAA;AAAA,EAE7B,YAAYC,eAAiB;AAAA;AAAA;AAAA,EAK7B,QAAQC,QAAgB;AAAA,EACxB,UAAUC,QAAgB;AAAA,EAC1B,eAAeC,QAAgB;AAAA,EAC/B,gBAAgBC,QAAgB;AAAA,EAChC,eAAeC,QAAgB;AAAA,EAC/B,iBAAiBC,QAAgB;AAAA,EACjC,iBAAiBC,QAAgB;AAAA,EACjC,cAAcC,QAAgB;AAAA;AAAA,EAE9B,OAAOC,QAAAA;AAER;;;;;;;;;;;;;;;;;;;;;;;"}