@autofleet/sadot 1.6.18-beta.2 → 1.6.18-beta.21

package/dist/api/v1/field-policies/index.cjs

@@ -0,0 +1,104 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../utils/logger/index.cjs');
+const require_errors = require('../errors.cjs');
+const require_mat_path_state = require('../../../mat-path-state.cjs');
+const require_field_policy = require('../../../repository/field-policy.cjs');
+let sequelize = require("sequelize");
+let _autofleet_node_common = require("@autofleet/node-common");
+
+//#region src/api/v1/field-policies/index.ts
+const router = (0, _autofleet_node_common.Router)({
+	logger: require_index.default,
+	mergeParams: true
+});
+router.get("/effective", async (req, res) => {
+	const { withMatPath } = require_mat_path_state.matPathState;
+	if (!withMatPath) return res.status(501).json({ error: "Effective field policy resolution is not configured" });
+	const entityType = req.params.entityType;
+	try {
+		const [policy] = await require_field_policy.findEffectivePolicy(entityType);
+		return res.status(200).json(policy ?? null);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error resolving effective field policy"
+		});
+	}
+});
+router.get("/", async (_req, res) => {
+	try {
+		const policies = await require_field_policy.findAll();
+		res.status(200).json(policies);
+	} catch (err) {
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in get field policies request"
+		});
+	}
+});
+router.post("/", async (req, res) => {
+	const { contextId, name, entityType, fields, models } = req.body;
+	if (!contextId || !name) {
+		res.status(400).json({ error: "contextId and name are required" });
+		return;
+	}
+	try {
+		const policy = await require_field_policy.create({
+			contextId,
+			name,
+			entityType,
+			fields,
+			models
+		});
+		res.status(201).json(policy);
+	} catch (err) {
+		if (err instanceof sequelize.UniqueConstraintError) {
+			res.status(409).json({ error: "A field policy for this contextId and name already exists" });
+			return;
+		}
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in create field policy request"
+		});
+	}
+});
+router.put("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	const { entityType, fields, models } = req.body;
+	try {
+		const updated = await require_field_policy.update(policyId, {
+			entityType,
+			fields,
+			models
+		});
+		if (!updated) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(200).json(updated);
+	} catch (err) {
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in update field policy request"
+		});
+	}
+});
+router.delete("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	try {
+		if (!await require_field_policy.remove(policyId)) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(204).send();
+	} catch (err) {
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in delete field policy request"
+		});
+	}
+});
+var field_policies_default = router;
+
+//#endregion
+exports.default = field_policies_default;

package/dist/api/v1/field-policies/index.js

@@ -0,0 +1,103 @@
+import logger_default from "../../../utils/logger/index.js";
+import errors_default from "../errors.js";
+import { matPathState } from "../../../mat-path-state.js";
+import { create, findAll, findEffectivePolicy, remove, update } from "../../../repository/field-policy.js";
+import { UniqueConstraintError } from "sequelize";
+import { Router } from "@autofleet/node-common";
+
+//#region src/api/v1/field-policies/index.ts
+const router = Router({
+	logger: logger_default,
+	mergeParams: true
+});
+router.get("/effective", async (req, res) => {
+	const { withMatPath } = matPathState;
+	if (!withMatPath) return res.status(501).json({ error: "Effective field policy resolution is not configured" });
+	const entityType = req.params.entityType;
+	try {
+		const [policy] = await findEffectivePolicy(entityType);
+		return res.status(200).json(policy ?? null);
+	} catch (err) {
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: "Error resolving effective field policy"
+		});
+	}
+});
+router.get("/", async (_req, res) => {
+	try {
+		const policies = await findAll();
+		res.status(200).json(policies);
+	} catch (err) {
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in get field policies request"
+		});
+	}
+});
+router.post("/", async (req, res) => {
+	const { contextId, name, entityType, fields, models } = req.body;
+	if (!contextId || !name) {
+		res.status(400).json({ error: "contextId and name are required" });
+		return;
+	}
+	try {
+		const policy = await create({
+			contextId,
+			name,
+			entityType,
+			fields,
+			models
+		});
+		res.status(201).json(policy);
+	} catch (err) {
+		if (err instanceof UniqueConstraintError) {
+			res.status(409).json({ error: "A field policy for this contextId and name already exists" });
+			return;
+		}
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in create field policy request"
+		});
+	}
+});
+router.put("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	const { entityType, fields, models } = req.body;
+	try {
+		const updated = await update(policyId, {
+			entityType,
+			fields,
+			models
+		});
+		if (!updated) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(200).json(updated);
+	} catch (err) {
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in update field policy request"
+		});
+	}
+});
+router.delete("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	try {
+		if (!await remove(policyId)) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(204).send();
+	} catch (err) {
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in delete field policy request"
+		});
+	}
+});
+var field_policies_default = router;
+
+//#endregion
+export { field_policies_default as default };

package/dist/api/v1/index.cjs

@@ -0,0 +1,16 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../utils/logger/index.cjs');
+const require_index$1 = require('./definition/index.cjs');
+const require_index$2 = require('./validator/index.cjs');
+const require_index$3 = require('./field-policies/index.cjs');
+let _autofleet_node_common = require("@autofleet/node-common");
+
+//#region src/api/v1/index.ts
+const router = (0, _autofleet_node_common.Router)({ logger: require_index.default });
+router.use("/custom-field-definitions/:modelName", require_index$1.default);
+router.use("/custom-validators/:modelName", require_index$2.default);
+router.use("/field-policies/:entityType", require_index$3.default);
+var v1_default = router;
+
+//#endregion
+exports.default = v1_default;

package/dist/api/v1/index.js

@@ -0,0 +1,15 @@
+import logger_default from "../../utils/logger/index.js";
+import definition_default from "./definition/index.js";
+import validator_default from "./validator/index.js";
+import field_policies_default from "./field-policies/index.js";
+import { Router } from "@autofleet/node-common";
+
+//#region src/api/v1/index.ts
+const router = Router({ logger: logger_default });
+router.use("/custom-field-definitions/:modelName", definition_default);
+router.use("/custom-validators/:modelName", validator_default);
+router.use("/field-policies/:entityType", field_policies_default);
+var v1_default = router;
+
+//#endregion
+export { v1_default as default };

package/dist/api/v1/validator/index.cjs

@@ -0,0 +1,132 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../utils/logger/index.cjs');
+const require_errors = require('../errors.cjs');
+const require_mat_path_state = require('../../../mat-path-state.cjs');
+const require_validator = require('../../../repository/validator.cjs');
+const require_validations = require('./validations.cjs');
+const require_validator_schema = require('../../../utils/validations/schema/validator-schema.cjs');
+let _autofleet_errors = require("@autofleet/errors");
+let _autofleet_node_common = require("@autofleet/node-common");
+let http_status_codes = require("http-status-codes");
+
+//#region src/api/v1/validator/index.ts
+const router = (0, _autofleet_node_common.Router)({ logger: require_index.default });
+const ENTITY = "CustomValidator";
+/**
+* Create
+*/
+router.post("/", async (req, res) => {
+	const { modelName } = req.params;
+	try {
+		const validatedPayload = await require_validations.default.create.validateAsync(req.body);
+		require_validator_schema.validateValidatorSchema(validatedPayload.schema);
+		const validator = await require_validator.create({
+			...validatedPayload,
+			modelType: modelName
+		});
+		return res.status(http_status_codes.StatusCodes.CREATED).json(validator);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in create ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get all
+*/
+router.get("/", async (req, res) => {
+	try {
+		const { modelName } = req.params;
+		const { entityId, entityType } = req.query;
+		const applyEntityFilters = !require_mat_path_state.matPathState.isMatPathEnabled?.();
+		const where = {
+			modelType: modelName,
+			...applyEntityFilters && entityId && { entityId },
+			...applyEntityFilters && entityType && { entityType }
+		};
+		const validators = await require_validator.findAll(where);
+		return res.status(http_status_codes.StatusCodes.OK).json({ validators });
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in get all ${ENTITY} request`
+		});
+	}
+});
+/**
+* Effective
+*/
+router.get("/effective", async (req, res) => {
+	const { withMatPath } = require_mat_path_state.matPathState;
+	if (!withMatPath) return res.status(http_status_codes.StatusCodes.NOT_IMPLEMENTED).json({ error: "Effective validator resolution is not configured" });
+	try {
+		const { modelName } = req.params;
+		const [validator] = await require_validator.findEffective(modelName);
+		return res.status(http_status_codes.StatusCodes.OK).json(validator ?? null);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error resolving effective ${ENTITY}`
+		});
+	}
+});
+/**
+* Get by id
+*/
+router.get("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId, modelName } = req.params;
+		const validators = await require_validator.findAll({
+			id: validatorId,
+			modelType: modelName
+		}, { withDisabled: true });
+		if (!validators.length) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		return res.status(http_status_codes.StatusCodes.OK).json(validators[0]);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in get ${ENTITY} request`
+		});
+	}
+});
+/**
+* Update
+*/
+router.patch("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId } = req.params;
+		const validatedPayload = await require_validations.default.update.validateAsync(req.body);
+		if (validatedPayload.schema) require_validator_schema.validateValidatorSchema(validatedPayload.schema);
+		if (!(await require_validator.findAll({ id: validatorId }, { withDisabled: true })).length) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		const [count, validators] = await require_validator.update(validatorId, validatedPayload);
+		if (!count) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		return res.status(http_status_codes.StatusCodes.OK).json(validators[0]);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in update ${ENTITY} request`
+		});
+	}
+});
+/**
+* Delete (disable)
+*/
+router.delete("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId } = req.params;
+		if (!(await require_validator.findAll({ id: validatorId }, { withDisabled: true })).length) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		const [count] = await require_validator.disable(validatorId);
+		if (!count) throw new _autofleet_errors.ResourceNotFoundError("Validator failed to be disabled");
+		return res.status(http_status_codes.StatusCodes.NO_CONTENT).send();
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in delete ${ENTITY} request`
+		});
+	}
+});
+var validator_default = router;
+
+//#endregion
+exports.default = validator_default;

package/dist/api/v1/validator/index.js

@@ -0,0 +1,131 @@
+import logger_default from "../../../utils/logger/index.js";
+import errors_default from "../errors.js";
+import { matPathState } from "../../../mat-path-state.js";
+import { create, disable, findAll, findEffective, update } from "../../../repository/validator.js";
+import validations_default from "./validations.js";
+import { validateValidatorSchema } from "../../../utils/validations/schema/validator-schema.js";
+import { ResourceNotFoundError } from "@autofleet/errors";
+import { Router } from "@autofleet/node-common";
+import { StatusCodes } from "http-status-codes";
+
+//#region src/api/v1/validator/index.ts
+const router = Router({ logger: logger_default });
+const ENTITY = "CustomValidator";
+/**
+* Create
+*/
+router.post("/", async (req, res) => {
+	const { modelName } = req.params;
+	try {
+		const validatedPayload = await validations_default.create.validateAsync(req.body);
+		validateValidatorSchema(validatedPayload.schema);
+		const validator = await create({
+			...validatedPayload,
+			modelType: modelName
+		});
+		return res.status(StatusCodes.CREATED).json(validator);
+	} catch (err) {
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in create ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get all
+*/
+router.get("/", async (req, res) => {
+	try {
+		const { modelName } = req.params;
+		const { entityId, entityType } = req.query;
+		const applyEntityFilters = !matPathState.isMatPathEnabled?.();
+		const where = {
+			modelType: modelName,
+			...applyEntityFilters && entityId && { entityId },
+			...applyEntityFilters && entityType && { entityType }
+		};
+		const validators = await findAll(where);
+		return res.status(StatusCodes.OK).json({ validators });
+	} catch (err) {
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in get all ${ENTITY} request`
+		});
+	}
+});
+/**
+* Effective
+*/
+router.get("/effective", async (req, res) => {
+	const { withMatPath } = matPathState;
+	if (!withMatPath) return res.status(StatusCodes.NOT_IMPLEMENTED).json({ error: "Effective validator resolution is not configured" });
+	try {
+		const { modelName } = req.params;
+		const [validator] = await findEffective(modelName);
+		return res.status(StatusCodes.OK).json(validator ?? null);
+	} catch (err) {
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error resolving effective ${ENTITY}`
+		});
+	}
+});
+/**
+* Get by id
+*/
+router.get("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId, modelName } = req.params;
+		const validators = await findAll({
+			id: validatorId,
+			modelType: modelName
+		}, { withDisabled: true });
+		if (!validators.length) throw new ResourceNotFoundError("Validator not found");
+		return res.status(StatusCodes.OK).json(validators[0]);
+	} catch (err) {
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in get ${ENTITY} request`
+		});
+	}
+});
+/**
+* Update
+*/
+router.patch("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId } = req.params;
+		const validatedPayload = await validations_default.update.validateAsync(req.body);
+		if (validatedPayload.schema) validateValidatorSchema(validatedPayload.schema);
+		if (!(await findAll({ id: validatorId }, { withDisabled: true })).length) throw new ResourceNotFoundError("Validator not found");
+		const [count, validators] = await update(validatorId, validatedPayload);
+		if (!count) throw new ResourceNotFoundError("Validator not found");
+		return res.status(StatusCodes.OK).json(validators[0]);
+	} catch (err) {
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in update ${ENTITY} request`
+		});
+	}
+});
+/**
+* Delete (disable)
+*/
+router.delete("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId } = req.params;
+		if (!(await findAll({ id: validatorId }, { withDisabled: true })).length) throw new ResourceNotFoundError("Validator not found");
+		const [count] = await disable(validatorId);
+		if (!count) throw new ResourceNotFoundError("Validator failed to be disabled");
+		return res.status(StatusCodes.NO_CONTENT).send();
+	} catch (err) {
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in delete ${ENTITY} request`
+		});
+	}
+});
+var validator_default = router;
+
+//#endregion
+export { validator_default as default };

package/dist/api/v1/validator/validations.cjs

@@ -0,0 +1,40 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let joi = require("joi");
+joi = require_rolldown_runtime.__toESM(joi);
+
+//#region src/api/v1/validator/validations.ts
+const jsonSchemaValidation = joi.default.object().unknown(true);
+const schemaObject = joi.default.object({
+	type: joi.default.string().valid("object"),
+	properties: joi.default.object({
+		before: jsonSchemaValidation,
+		after: jsonSchemaValidation
+	}).required(),
+	required: joi.default.array().items(joi.default.string()),
+	allOf: joi.default.array().items(joi.default.object()),
+	anyOf: joi.default.array().items(joi.default.object()),
+	oneOf: joi.default.array().items(joi.default.object()),
+	additionalProperties: joi.default.alternatives().try(joi.default.boolean(), joi.default.object()),
+	$id: joi.default.string(),
+	$schema: joi.default.string(),
+	if: joi.default.object(),
+	then: joi.default.object(),
+	else: joi.default.object()
+});
+const validationSchemas = {
+	create: joi.default.object({
+		entityId: joi.default.string().uuid().required(),
+		entityType: joi.default.string().required(),
+		schema: schemaObject.required()
+	}),
+	update: joi.default.object({
+		entityId: joi.default.string().uuid(),
+		entityType: joi.default.string(),
+		schema: schemaObject,
+		disabled: joi.default.boolean()
+	}).min(1)
+};
+var validations_default = validationSchemas;
+
+//#endregion
+exports.default = validations_default;

package/dist/api/v1/validator/validations.d.cts

@@ -0,0 +1,22 @@
+import Joi from "joi";
+
+//#region src/api/v1/validator/validations.d.ts
+interface SchemaObject {
+  type: "object";
+  properties?: {
+    before?: object;
+    after?: object;
+  };
+  required?: string[];
+  allOf?: object[];
+  anyOf?: object[];
+  oneOf?: object[];
+  additionalProperties?: boolean | object;
+  $id?: string;
+  $schema?: string;
+  if?: object;
+  then?: object;
+  else?: object;
+}
+//#endregion
+export { SchemaObject };

package/dist/api/v1/validator/validations.d.ts

@@ -0,0 +1,22 @@
+import Joi from "joi";
+
+//#region src/api/v1/validator/validations.d.ts
+interface SchemaObject {
+  type: "object";
+  properties?: {
+    before?: object;
+    after?: object;
+  };
+  required?: string[];
+  allOf?: object[];
+  anyOf?: object[];
+  oneOf?: object[];
+  additionalProperties?: boolean | object;
+  $id?: string;
+  $schema?: string;
+  if?: object;
+  then?: object;
+  else?: object;
+}
+//#endregion
+export { SchemaObject };

package/dist/api/v1/validator/validations.js

@@ -0,0 +1,38 @@
+import Joi from "joi";
+
+//#region src/api/v1/validator/validations.ts
+const jsonSchemaValidation = Joi.object().unknown(true);
+const schemaObject = Joi.object({
+	type: Joi.string().valid("object"),
+	properties: Joi.object({
+		before: jsonSchemaValidation,
+		after: jsonSchemaValidation
+	}).required(),
+	required: Joi.array().items(Joi.string()),
+	allOf: Joi.array().items(Joi.object()),
+	anyOf: Joi.array().items(Joi.object()),
+	oneOf: Joi.array().items(Joi.object()),
+	additionalProperties: Joi.alternatives().try(Joi.boolean(), Joi.object()),
+	$id: Joi.string(),
+	$schema: Joi.string(),
+	if: Joi.object(),
+	then: Joi.object(),
+	else: Joi.object()
+});
+const validationSchemas = {
+	create: Joi.object({
+		entityId: Joi.string().uuid().required(),
+		entityType: Joi.string().required(),
+		schema: schemaObject.required()
+	}),
+	update: Joi.object({
+		entityId: Joi.string().uuid(),
+		entityType: Joi.string(),
+		schema: schemaObject,
+		disabled: Joi.boolean()
+	}).min(1)
+};
+var validations_default = validationSchemas;
+
+//#endregion
+export { validations_default as default };

package/dist/errors/index.cjs

@@ -0,0 +1,62 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _autofleet_errors = require("@autofleet/errors");
+
+//#region src/errors/index.ts
+var MissingRequiredCustomFieldError = class extends _autofleet_errors.BadRequest {
+	constructor(missingFields) {
+		const err = /* @__PURE__ */ new Error(`The following custom fields are required: ${missingFields.join(",")}`);
+		super([err], void 0, missingFields);
+		this.message = "MISSING_REQUIRED_CUSTOM_FIELDS";
+	}
+};
+var UnsupportedCustomFieldTypeError = class extends _autofleet_errors.BadRequest {
+	constructor(fieldType) {
+		const err = /* @__PURE__ */ new Error(`Type "${fieldType}" is not supported`);
+		super([err], void 0, null);
+		this.message = "UNSUPPORTED_CUSTOM_FIELD_TYPE";
+	}
+};
+var UnsupportedCustomValidationError = class extends _autofleet_errors.BadRequest {
+	constructor(fieldType) {
+		const err = /* @__PURE__ */ new Error(`Validation for "${fieldType}" is not supported`);
+		super([err], void 0, null);
+		this.message = "UNSUPPORTED_CUSTOM_VALIDATION_TYPE";
+	}
+};
+var InvalidFieldTypeError = class extends _autofleet_errors.BadRequest {
+	constructor(fieldType) {
+		const err = /* @__PURE__ */ new Error(`Invalid field type ${fieldType}`);
+		super([err], void 0, null);
+		this.message = "INVALID_FIELD_TYPE";
+	}
+};
+var InvalidValueError = class extends _autofleet_errors.BadRequest {
+	constructor(value, fieldDefinitionName, joiValidationError) {
+		const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${joiValidationError.message.replace(/"/g, "").replace("value", `'${fieldDefinitionName}'`)}. received: '${typeof value === "object" ? JSON.stringify(value) : value}'`;
+		super([new Error(invalidValueMessage)], void 0, null);
+		this.message = invalidValueMessage;
+	}
+};
+var InvalidEntriesError = class extends _autofleet_errors.BadRequest {
+	constructor(modelId, validationErrors) {
+		const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
+		super(errors, void 0, null);
+		this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => `${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`).join("\n")}`;
+	}
+};
+var MissingDefinitionError = class extends _autofleet_errors.BadRequest {
+	constructor(fieldNames) {
+		const err = /* @__PURE__ */ new Error(`Missing custom field definition for field ${fieldNames.join(",")}`);
+		super([err], void 0, null);
+		this.message = "MISSING_DEFINITION";
+	}
+};
+
+//#endregion
+exports.InvalidEntriesError = InvalidEntriesError;
+exports.InvalidFieldTypeError = InvalidFieldTypeError;
+exports.InvalidValueError = InvalidValueError;
+exports.MissingDefinitionError = MissingDefinitionError;
+exports.MissingRequiredCustomFieldError = MissingRequiredCustomFieldError;
+exports.UnsupportedCustomFieldTypeError = UnsupportedCustomFieldTypeError;
+exports.UnsupportedCustomValidationError = UnsupportedCustomValidationError;