@tailor-platform/sdk 1.11.0 → 1.12.0

package/dist/schema-BmKdDzr1.mjs

@@ -0,0 +1,784 @@
+import { cloneDeep } from "es-toolkit";
+
+//#region src/configure/types/field.ts
+/**
+* Normalize allowed values into EnumValue objects with descriptions.
+* @param values - Allowed values as strings or EnumValue objects
+* @returns Normalized allowed values
+*/
+function mapAllowedValues(values) {
+	return values.map((value) => {
+		if (typeof value === "string") return {
+			value,
+			description: ""
+		};
+		return {
+			...value,
+			description: value.description ?? ""
+		};
+	});
+}
+
+//#endregion
+//#region src/configure/types/type.ts
+const regex$1 = {
+	uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+	date: /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/,
+	time: /^(?<hour>\d{2}):(?<minute>\d{2})$/,
+	datetime: /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2})(.(?<millisec>\d{3}))?Z$/
+};
+/**
+* Creates a new TailorField instance.
+* @param type - Field type
+* @param options - Field options
+* @param fields - Nested fields for object-like types
+* @param values - Allowed values for enum-like fields
+* @returns A new TailorField
+*/
+function createTailorField(type, options, fields, values) {
+	const _metadata = { required: true };
+	if (options) {
+		const hasRequired = Object.prototype.hasOwnProperty.call(options, "required");
+		const hasOptional = Object.prototype.hasOwnProperty.call(options, "optional");
+		if (hasRequired) {
+			const isRequired = options.required === true;
+			_metadata.required = isRequired;
+			if (isRequired) _metadata.requiredExplicit = true;
+		} else if (hasOptional) {
+			_metadata.required = !(options.optional === true);
+			if (options.optional === false) _metadata.requiredExplicit = true;
+		}
+		if (options.array === true) _metadata.array = true;
+	}
+	if (values) _metadata.allowedValues = mapAllowedValues(values);
+	/**
+	* Validate a single value (not an array element)
+	* Used internally for array element validation
+	* @param args - Value, context data, and user
+	* @returns Array of validation issues
+	*/
+	function validateValue(args) {
+		const { value, data, user, pathArray } = args;
+		const issues = [];
+		switch (type) {
+			case "string":
+				if (typeof value !== "string") issues.push({
+					message: `Expected a string: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "integer":
+				if (typeof value !== "number" || !Number.isInteger(value)) issues.push({
+					message: `Expected an integer: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "float":
+				if (typeof value !== "number" || !Number.isFinite(value)) issues.push({
+					message: `Expected a number: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "boolean":
+				if (typeof value !== "boolean") issues.push({
+					message: `Expected a boolean: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "uuid":
+				if (typeof value !== "string" || !regex$1.uuid.test(value)) issues.push({
+					message: `Expected a valid UUID: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "date":
+				if (typeof value !== "string" || !regex$1.date.test(value)) issues.push({
+					message: `Expected to match "yyyy-MM-dd" format: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "datetime":
+				if (typeof value !== "string" || !regex$1.datetime.test(value)) issues.push({
+					message: `Expected to match ISO format: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "time":
+				if (typeof value !== "string" || !regex$1.time.test(value)) issues.push({
+					message: `Expected to match "HH:mm" format: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "enum":
+				if (field._metadata.allowedValues) {
+					const allowedValues = field._metadata.allowedValues.map((v) => v.value);
+					if (typeof value !== "string" || !allowedValues.includes(value)) issues.push({
+						message: `Must be one of [${allowedValues.join(", ")}]: received ${String(value)}`,
+						path: pathArray.length > 0 ? pathArray : void 0
+					});
+				}
+				break;
+			case "nested":
+				if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) issues.push({
+					message: `Expected an object: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				else if (field.fields && Object.keys(field.fields).length > 0) for (const [fieldName, nestedField] of Object.entries(field.fields)) {
+					const fieldValue = value?.[fieldName];
+					const result = nestedField._parseInternal({
+						value: fieldValue,
+						data,
+						user,
+						pathArray: pathArray.concat(fieldName)
+					});
+					if (result.issues) issues.push(...result.issues);
+				}
+				break;
+		}
+		const validateFns = field._metadata.validate;
+		if (validateFns && validateFns.length > 0) for (const validateInput of validateFns) {
+			const { fn, message } = typeof validateInput === "function" ? {
+				fn: validateInput,
+				message: "Validation failed"
+			} : {
+				fn: validateInput[0],
+				message: validateInput[1]
+			};
+			if (!fn({
+				value,
+				data,
+				user
+			})) issues.push({
+				message,
+				path: pathArray.length > 0 ? pathArray : void 0
+			});
+		}
+		return issues;
+	}
+	/**
+	* Internal parse method that tracks field path for nested validation
+	* @param args - Parse arguments
+	* @returns Parse result with value or issues
+	*/
+	function parseInternal(args) {
+		const { value, data, user, pathArray } = args;
+		const issues = [];
+		const isNullOrUndefined = value === null || value === void 0;
+		if (field._metadata.required && isNullOrUndefined) {
+			issues.push({
+				message: "Required field is missing",
+				path: pathArray.length > 0 ? pathArray : void 0
+			});
+			return { issues };
+		}
+		if (!field._metadata.required && isNullOrUndefined) return { value: value ?? null };
+		if (field._metadata.array) {
+			if (!Array.isArray(value)) {
+				issues.push({
+					message: "Expected an array",
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				return { issues };
+			}
+			for (let i = 0; i < value.length; i++) {
+				const elementValue = value[i];
+				const elementIssues = validateValue({
+					value: elementValue,
+					data,
+					user,
+					pathArray: pathArray.concat(`[${i}]`)
+				});
+				if (elementIssues.length > 0) issues.push(...elementIssues);
+			}
+			if (issues.length > 0) return { issues };
+			return { value };
+		}
+		const valueIssues = validateValue({
+			value,
+			data,
+			user,
+			pathArray
+		});
+		issues.push(...valueIssues);
+		if (issues.length > 0) return { issues };
+		return { value };
+	}
+	const field = {
+		type,
+		fields: fields ?? {},
+		_defined: void 0,
+		_output: void 0,
+		_metadata,
+		get metadata() {
+			return { ...this._metadata };
+		},
+		description(description) {
+			this._metadata.description = description;
+			return this;
+		},
+		typeName(typeName) {
+			this._metadata.typeName = typeName;
+			return this;
+		},
+		validate(...validateInputs) {
+			this._metadata.validate = validateInputs;
+			return this;
+		},
+		parse(args) {
+			return parseInternal({
+				value: args.value,
+				data: args.data,
+				user: args.user,
+				pathArray: []
+			});
+		},
+		_parseInternal: parseInternal
+	};
+	return field;
+}
+function uuid$1(options) {
+	return createTailorField("uuid", options);
+}
+function string$1(options) {
+	return createTailorField("string", options);
+}
+function bool$1(options) {
+	return createTailorField("boolean", options);
+}
+function int$1(options) {
+	return createTailorField("integer", options);
+}
+function float$1(options) {
+	return createTailorField("float", options);
+}
+function date$1(options) {
+	return createTailorField("date", options);
+}
+function datetime$1(options) {
+	return createTailorField("datetime", options);
+}
+function time$1(options) {
+	return createTailorField("time", options);
+}
+function _enum$1(values, options) {
+	return createTailorField("enum", options, void 0, values);
+}
+function object$1(fields, options) {
+	return createTailorField("nested", options, fields);
+}
+const t = {
+	uuid: uuid$1,
+	string: string$1,
+	bool: bool$1,
+	int: int$1,
+	float: float$1,
+	date: date$1,
+	datetime: datetime$1,
+	time: time$1,
+	enum: _enum$1,
+	object: object$1
+};
+
+//#endregion
+//#region src/configure/services/tailordb/permission.ts
+/**
+* Grants full record-level access without any conditions.
+*
+* Unsafe and intended only for local development, prototyping, or tests.
+* Do not use this in production environments, as it effectively disables
+* authorization checks.
+*/
+const unsafeAllowAllTypePermission = {
+	create: [{
+		conditions: [],
+		permit: true
+	}],
+	read: [{
+		conditions: [],
+		permit: true
+	}],
+	update: [{
+		conditions: [],
+		permit: true
+	}],
+	delete: [{
+		conditions: [],
+		permit: true
+	}]
+};
+/**
+* Grants full GraphQL access (all actions) without any conditions.
+*
+* Unsafe and intended only for local development, prototyping, or tests.
+* Do not use this in production environments, as it effectively disables
+* authorization checks.
+*/
+const unsafeAllowAllGqlPermission = [{
+	conditions: [],
+	actions: "all",
+	permit: true
+}];
+
+//#endregion
+//#region src/configure/services/tailordb/schema.ts
+function isRelationSelfConfig(config) {
+	return config.toward.type === "self";
+}
+const regex = {
+	uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+	date: /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/,
+	time: /^(?<hour>\d{2}):(?<minute>\d{2})$/,
+	datetime: /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2})(.(?<millisec>\d{3}))?Z$/
+};
+/**
+* Creates a new TailorDBField instance.
+* @param type - Field type
+* @param options - Field options
+* @param fields - Nested fields for object-like types
+* @param values - Allowed values for enum-like fields
+* @returns A new TailorDBField
+*/
+function createTailorDBField(type, options, fields, values) {
+	const _metadata = { required: true };
+	let _rawRelation;
+	if (options) {
+		if (options.optional === true) _metadata.required = false;
+		if (options.array === true) _metadata.array = true;
+	}
+	if (values) _metadata.allowedValues = mapAllowedValues(values);
+	/**
+	* Validate a single value (not an array element)
+	* Used internally for array element validation
+	* @param args - Value, context data, and user
+	* @returns Array of validation issues
+	*/
+	function validateValue(args) {
+		const { value, data, user, pathArray } = args;
+		const issues = [];
+		switch (type) {
+			case "string":
+				if (typeof value !== "string") issues.push({
+					message: `Expected a string: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "integer":
+				if (typeof value !== "number" || !Number.isInteger(value)) issues.push({
+					message: `Expected an integer: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "float":
+				if (typeof value !== "number" || !Number.isFinite(value)) issues.push({
+					message: `Expected a number: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "boolean":
+				if (typeof value !== "boolean") issues.push({
+					message: `Expected a boolean: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "uuid":
+				if (typeof value !== "string" || !regex.uuid.test(value)) issues.push({
+					message: `Expected a valid UUID: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "date":
+				if (typeof value !== "string" || !regex.date.test(value)) issues.push({
+					message: `Expected to match "yyyy-MM-dd" format: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "datetime":
+				if (typeof value !== "string" || !regex.datetime.test(value)) issues.push({
+					message: `Expected to match ISO format: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "time":
+				if (typeof value !== "string" || !regex.time.test(value)) issues.push({
+					message: `Expected to match "HH:mm" format: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				break;
+			case "enum":
+				if (field._metadata.allowedValues) {
+					const allowedValues = field._metadata.allowedValues.map((v) => v.value);
+					if (typeof value !== "string" || !allowedValues.includes(value)) issues.push({
+						message: `Must be one of [${allowedValues.join(", ")}]: received ${String(value)}`,
+						path: pathArray.length > 0 ? pathArray : void 0
+					});
+				}
+				break;
+			case "nested":
+				if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) issues.push({
+					message: `Expected an object: received ${String(value)}`,
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				else if (field.fields && Object.keys(field.fields).length > 0) for (const [fieldName, nestedField] of Object.entries(field.fields)) {
+					const fieldValue = value?.[fieldName];
+					const result = nestedField._parseInternal({
+						value: fieldValue,
+						data,
+						user,
+						pathArray: pathArray.concat(fieldName)
+					});
+					if (result.issues) issues.push(...result.issues);
+				}
+				break;
+		}
+		const validateFns = field._metadata.validate;
+		if (validateFns && validateFns.length > 0) for (const validateInput of validateFns) {
+			const { fn, message } = typeof validateInput === "function" ? {
+				fn: validateInput,
+				message: "Validation failed"
+			} : {
+				fn: validateInput[0],
+				message: validateInput[1]
+			};
+			if (!fn({
+				value,
+				data,
+				user
+			})) issues.push({
+				message,
+				path: pathArray.length > 0 ? pathArray : void 0
+			});
+		}
+		return issues;
+	}
+	/**
+	* Internal parse method that tracks field path for nested validation
+	* @param args - Parse arguments
+	* @returns Parse result with value or issues
+	*/
+	function parseInternal(args) {
+		const { value, data, user, pathArray } = args;
+		const issues = [];
+		const isNullOrUndefined = value === null || value === void 0;
+		if (field._metadata.required && isNullOrUndefined) {
+			issues.push({
+				message: "Required field is missing",
+				path: pathArray.length > 0 ? pathArray : void 0
+			});
+			return { issues };
+		}
+		if (!field._metadata.required && isNullOrUndefined) return { value: value ?? null };
+		if (field._metadata.array) {
+			if (!Array.isArray(value)) {
+				issues.push({
+					message: "Expected an array",
+					path: pathArray.length > 0 ? pathArray : void 0
+				});
+				return { issues };
+			}
+			for (let i = 0; i < value.length; i++) {
+				const elementValue = value[i];
+				const elementIssues = validateValue({
+					value: elementValue,
+					data,
+					user,
+					pathArray: pathArray.concat(`[${i}]`)
+				});
+				if (elementIssues.length > 0) issues.push(...elementIssues);
+			}
+			if (issues.length > 0) return { issues };
+			return { value };
+		}
+		const valueIssues = validateValue({
+			value,
+			data,
+			user,
+			pathArray
+		});
+		issues.push(...valueIssues);
+		if (issues.length > 0) return { issues };
+		return { value };
+	}
+	function cloneWith(metadataUpdates) {
+		const cloned = field.clone();
+		Object.assign(cloned._metadata, metadataUpdates);
+		return cloned;
+	}
+	const field = {
+		type,
+		fields: fields ?? {},
+		_defined: void 0,
+		_output: void 0,
+		_metadata,
+		get metadata() {
+			return { ...this._metadata };
+		},
+		get rawRelation() {
+			return _rawRelation ? {
+				..._rawRelation,
+				toward: { ..._rawRelation.toward }
+			} : void 0;
+		},
+		description(description) {
+			return cloneWith({ description });
+		},
+		typeName(typeName) {
+			return cloneWith({ typeName });
+		},
+		validate(...validateInputs) {
+			return cloneWith({ validate: validateInputs });
+		},
+		parse(args) {
+			return parseInternal({
+				value: args.value,
+				data: args.data,
+				user: args.user,
+				pathArray: []
+			});
+		},
+		_parseInternal: parseInternal,
+		relation(config) {
+			const cloned = field.clone();
+			const targetType = isRelationSelfConfig(config) ? "self" : config.toward.type.name;
+			cloned._setRawRelation({
+				type: config.type,
+				toward: {
+					type: targetType,
+					as: config.toward.as,
+					key: config.toward.key
+				},
+				backward: config.backward
+			});
+			return cloned;
+		},
+		index() {
+			return cloneWith({ index: true });
+		},
+		unique() {
+			return cloneWith({
+				unique: true,
+				index: true
+			});
+		},
+		vector() {
+			return cloneWith({ vector: true });
+		},
+		hooks(hooks) {
+			return cloneWith({ hooks });
+		},
+		serial(config) {
+			return cloneWith({ serial: config });
+		},
+		clone(cloneOptions) {
+			let clonedFields = fields;
+			if (fields) {
+				const cloned = {};
+				for (const [key, field$1] of Object.entries(fields)) cloned[key] = field$1.clone();
+				clonedFields = cloned;
+			}
+			const clonedField = createTailorDBField(type, options, clonedFields, values);
+			Object.assign(clonedField._metadata, cloneDeep(this._metadata));
+			if (cloneOptions) {
+				if (cloneOptions.optional !== void 0) clonedField._metadata.required = !cloneOptions.optional;
+				if (cloneOptions.array !== void 0) clonedField._metadata.array = cloneOptions.array;
+			}
+			if (_rawRelation) {
+				const clonedRawRelation = cloneDeep(_rawRelation);
+				clonedField._setRawRelation(clonedRawRelation);
+			}
+			return clonedField;
+		},
+		_setRawRelation(relation) {
+			_rawRelation = relation;
+		}
+	};
+	return field;
+}
+const createField = createTailorDBField;
+function uuid(options) {
+	return createField("uuid", options);
+}
+function string(options) {
+	return createField("string", options);
+}
+function bool(options) {
+	return createField("boolean", options);
+}
+function int(options) {
+	return createField("integer", options);
+}
+function float(options) {
+	return createField("float", options);
+}
+function date(options) {
+	return createField("date", options);
+}
+function datetime(options) {
+	return createField("datetime", options);
+}
+function time(options) {
+	return createField("time", options);
+}
+function _enum(values, options) {
+	return createField("enum", options, void 0, values);
+}
+function object(fields, options) {
+	return createField("nested", options, fields);
+}
+/**
+* Creates a new TailorDBType instance.
+* @param name - Type name
+* @param fields - Field definitions
+* @param options - Type options
+* @param options.pluralForm - Optional plural form
+* @param options.description - Optional description
+* @returns A new TailorDBType
+*/
+function createTailorDBType(name, fields, options) {
+	let _description = options.description;
+	let _settings = {};
+	let _indexes = [];
+	const _permissions = {};
+	let _files = {};
+	const _plugins = [];
+	if (options.pluralForm) {
+		if (name === options.pluralForm) throw new Error(`The name and the plural form must be different. name=${name}`);
+		_settings.pluralForm = options.pluralForm;
+	}
+	return {
+		name,
+		fields: { ...fields },
+		_output: null,
+		_description,
+		get metadata() {
+			const indexes = {};
+			if (_indexes && _indexes.length > 0) _indexes.forEach((index) => {
+				const fieldNames = index.fields.map((field) => String(field));
+				const key = index.name || `idx_${fieldNames.join("_")}`;
+				indexes[key] = {
+					fields: fieldNames,
+					unique: index.unique
+				};
+			});
+			return {
+				name: this.name,
+				description: _description,
+				settings: _settings,
+				permissions: _permissions,
+				files: _files,
+				...Object.keys(indexes).length > 0 && { indexes }
+			};
+		},
+		hooks(hooks) {
+			Object.entries(hooks).forEach(([fieldName, fieldHooks]) => {
+				this.fields[fieldName] = this.fields[fieldName].hooks(fieldHooks);
+			});
+			return this;
+		},
+		validate(validators) {
+			Object.entries(validators).forEach(([fieldName, fieldValidators]) => {
+				const field = this.fields[fieldName];
+				const validators$1 = fieldValidators;
+				const isValidateConfig = (v) => {
+					return Array.isArray(v) && v.length === 2 && typeof v[1] === "string";
+				};
+				let updatedField;
+				if (Array.isArray(validators$1)) if (isValidateConfig(validators$1)) updatedField = field.validate(validators$1);
+				else updatedField = field.validate(...validators$1);
+				else updatedField = field.validate(validators$1);
+				this.fields[fieldName] = updatedField;
+			});
+			return this;
+		},
+		features(features) {
+			_settings = {
+				..._settings,
+				...features
+			};
+			return this;
+		},
+		indexes(...indexes) {
+			_indexes = indexes;
+			return this;
+		},
+		files(files) {
+			_files = files;
+			return this;
+		},
+		permission(permission) {
+			const ret = this;
+			_permissions.record = permission;
+			return ret;
+		},
+		gqlPermission(permission) {
+			const ret = this;
+			_permissions.gql = permission;
+			return ret;
+		},
+		description(description) {
+			_description = description;
+			this._description = description;
+			return this;
+		},
+		pickFields(keys, options$1) {
+			const result = {};
+			for (const key of keys) if (options$1) result[key] = this.fields[key].clone(options$1);
+			else result[key] = this.fields[key];
+			return result;
+		},
+		omitFields(keys) {
+			const keysSet = new Set(keys);
+			const result = {};
+			for (const key in this.fields) if (Object.hasOwn(this.fields, key) && !keysSet.has(key)) result[key] = this.fields[key];
+			return result;
+		},
+		get plugins() {
+			return _plugins;
+		},
+		plugin(config) {
+			for (const [pluginId, pluginConfig] of Object.entries(config)) _plugins.push({
+				pluginId,
+				config: pluginConfig
+			});
+			return this;
+		}
+	};
+}
+const idField = uuid();
+function dbType(name, fieldsOrDescription, fields) {
+	const typeName = Array.isArray(name) ? name[0] : name;
+	const pluralForm = Array.isArray(name) ? name[1] : void 0;
+	let description;
+	let fieldDef;
+	if (typeof fieldsOrDescription === "string") {
+		description = fieldsOrDescription;
+		fieldDef = fields;
+	} else fieldDef = fieldsOrDescription;
+	return createTailorDBType(typeName, {
+		id: idField,
+		...fieldDef
+	}, {
+		pluralForm,
+		description
+	});
+}
+const db = {
+	type: dbType,
+	uuid,
+	string,
+	bool,
+	int,
+	float,
+	date,
+	datetime,
+	time,
+	enum: _enum,
+	object,
+	fields: { timestamps: () => ({
+		createdAt: datetime().hooks({ create: () => /* @__PURE__ */ new Date() }).description("Record creation timestamp"),
+		updatedAt: datetime({ optional: true }).hooks({ update: () => /* @__PURE__ */ new Date() }).description("Record last update timestamp")
+	}) }
+};
+
+//#endregion
+export { t as i, unsafeAllowAllGqlPermission as n, unsafeAllowAllTypePermission as r, db as t };
+//# sourceMappingURL=schema-BmKdDzr1.mjs.map