@tailor-platform/sdk 2.0.0-next.1 → 2.0.0-next.10

package/dist/{schema-BhkpP5Hw.mjs → schema--xYWRGfe.mjs}

@@ -1,191 +1,236 @@
-import { t as mapAllowedValues } from "./field-DOsJCPFa.mjs";
 import { t as brandValue } from "./brand-Eo4pLXPJ.mjs";
 import { cloneDeep } from "es-toolkit";
 
-//#region src/configure/services/tailordb/schema.ts
-function isRelationSelfConfig(config) {
-	return config.toward.type === "self";
-}
+//#region src/runtime/field-parse.ts
 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$/,
+	time: /^(?<hour>[01]\d|2[0-3]):(?<minute>[0-5]\d)$/,
+	datetime: /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})[Tt](?<hour>[01]\d|2[0-3]):(?<minute>[0-5]\d):(?<second>[0-5]\d|60)(\.(?<fraction>\d+))?(?<offset>[Zz]|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/,
 	decimal: /^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/
 };
-/**
-* 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 "decimal":
-				if (typeof value !== "string" || !regex.decimal.test(value)) issues.push({
-					message: `Expected a decimal string: received ${String(value)}`,
-					path: pathArray.length > 0 ? pathArray : void 0
+function validateBaseValue(args) {
+	const { field, value, pathArray, issues } = args;
+	const path = pathArray.length > 0 ? pathArray : void 0;
+	const initialIssueCount = issues.length;
+	switch (field.type) {
+		case "string":
+			if (typeof value !== "string") issues.push({
+				message: `Expected a string: received ${String(value)}`,
+				path
+			});
+			break;
+		case "integer":
+			if (typeof value !== "number" || !Number.isInteger(value)) issues.push({
+				message: `Expected an integer: received ${String(value)}`,
+				path
+			});
+			break;
+		case "float":
+			if (typeof value !== "number" || !Number.isFinite(value)) issues.push({
+				message: `Expected a number: received ${String(value)}`,
+				path
+			});
+			break;
+		case "boolean":
+			if (typeof value !== "boolean") issues.push({
+				message: `Expected a boolean: received ${String(value)}`,
+				path
+			});
+			break;
+		case "uuid":
+			if (typeof value !== "string" || !regex.uuid.test(value)) issues.push({
+				message: `Expected a valid UUID: received ${String(value)}`,
+				path
+			});
+			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
+			});
+			break;
+		case "datetime":
+			if (typeof value !== "string" || !regex.datetime.test(value)) issues.push({
+				message: `Expected to match ISO format: received ${String(value)}`,
+				path
+			});
+			break;
+		case "time":
+			if (typeof value !== "string" || !regex.time.test(value)) issues.push({
+				message: `Expected to match "HH:mm" format: received ${String(value)}`,
+				path
+			});
+			break;
+		case "decimal":
+			if (typeof value !== "string" || !regex.decimal.test(value)) issues.push({
+				message: `Expected a decimal string: received ${String(value)}`,
+				path
+			});
+			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
 				});
-				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({
+			}
+			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
+					path
 				});
-				else if (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 false;
+			}
+			let nestedBaseValid = true;
+			for (const [fieldName, nestedField] of Object.entries(field.fields)) {
+				const fieldValue = value[fieldName];
+				if (!validateBaseField({
+					...args,
+					field: nestedField,
+					value: fieldValue,
+					pathArray: pathArray.concat(fieldName)
+				})) nestedBaseValid = false;
+			}
+			return nestedBaseValid;
 		}
-		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) {
+	return issues.length === initialIssueCount;
+}
+function validateCustomValue(args, validateFns) {
+	const { value, pathArray, issues } = args;
+	const path = pathArray.length > 0 ? pathArray : void 0;
+	for (const fn of validateFns) {
+		const result = fn({ value });
+		if (typeof result === "string") issues.push({
+			message: result,
+			path
+		});
+	}
+}
+function validateBaseField(args) {
+	const { field, value, pathArray, issues } = args;
+	const path = pathArray.length > 0 ? pathArray : void 0;
+	const isNullOrUndefined = value === null || value === void 0;
+	if (field._metadata.required && isNullOrUndefined) {
+		issues.push({
+			message: "Required field is missing",
+			path
+		});
+		return false;
+	}
+	if (!field._metadata.required && isNullOrUndefined) return true;
+	let baseValid = true;
+	if (field._metadata.array) {
+		if (!Array.isArray(value)) {
 			issues.push({
-				message: "Required field is missing",
-				path: pathArray.length > 0 ? pathArray : void 0
+				message: "Expected an array",
+				path
 			});
-			return { issues };
+			return false;
 		}
-		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 };
+		for (let i = 0; i < value.length; i++) if (!validateBaseValue({
+			...args,
+			value: value[i],
+			pathArray: pathArray.concat(`[${i}]`)
+		})) baseValid = false;
+	} else baseValid = validateBaseValue(args);
+	return baseValid;
+}
+function validateCustomField(args) {
+	const { field, value, pathArray } = args;
+	if (value === null || value === void 0) return;
+	if (field.type === "nested") {
+		const records = field._metadata.array ? value : [value];
+		for (let i = 0; i < records.length; i++) {
+			const record = records[i];
+			const recordPath = field._metadata.array ? pathArray.concat(`[${i}]`) : pathArray;
+			for (const [fieldName, nestedField] of Object.entries(field.fields)) validateCustomField({
+				...args,
+				field: nestedField,
+				value: record[fieldName],
+				pathArray: recordPath.concat(fieldName)
+			});
 		}
-		const valueIssues = validateValue({
+	}
+	const validateFns = field._metadata.validate;
+	if (validateFns?.length) validateCustomValue(args, validateFns);
+}
+function parseInternal(args) {
+	const { value } = args;
+	const issues = [];
+	const validationArgs = {
+		...args,
+		issues
+	};
+	if (validateBaseField(validationArgs)) validateCustomField(validationArgs);
+	if (issues.length > 0) return { issues };
+	return { value: value ?? null };
+}
+/**
+* Validate a value against a record of input fields, treating the record as a
+* single required object — the same code path deployed functions run via
+* `t.object(fields).parse(...)`, so local validation matches platform behavior.
+* @param args - Input field definitions plus the value, context data, and user
+* @returns Validation result
+*/
+function parseInputFields(args) {
+	const { fields, ...parseArgs } = args;
+	return parseInternal({
+		...parseArgs,
+		field: {
+			type: "nested",
+			fields,
+			_metadata: { required: true }
+		},
+		pathArray: []
+	});
+}
+
+//#endregion
+//#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,
-			data,
-			user,
-			pathArray
+			description: ""
+		};
+		return {
+			...value,
+			description: value.description ?? ""
+		};
+	});
+}
+
+//#endregion
+//#region src/configure/services/tailordb/schema.ts
+function isRelationSelfConfig(config) {
+	return config.toward.type === "self";
+}
+function createTailorDBField(type, options, fields, values) {
+	return createTailorDBFieldRuntime(type, options, fields, values);
+}
+function createTailorDBFieldRuntime(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);
+	function parseInternal$1(args) {
+		return parseInternal({
+			...args,
+			field
 		});
-		issues.push(...valueIssues);
-		if (issues.length > 0) return { issues };
-		return { value };
 	}
 	function cloneWith(metadataUpdates) {
 		const cloned = field.clone();
@@ -210,19 +255,20 @@ function createTailorDBField(type, options, fields, values) {
 		description(description) {
 			return cloneWith({ description });
 		},
-		typeName: ((typeName) => cloneWith({ typeName })),
+		typeName(typeName) {
+			return cloneWith({ typeName });
+		},
 		validate(...validateInputs) {
 			return cloneWith({ validate: validateInputs });
 		},
 		parse(args) {
-			return parseInternal({
+			return parseInternal$1({
 				value: args.value,
 				data: args.data,
-				user: args.user,
+				invoker: args.invoker,
 				pathArray: []
 			});
 		},
-		_parseInternal: parseInternal,
 		relation(config) {
 			const cloned = field.clone();
 			const targetType = isRelationSelfConfig(config) ? "self" : config.toward.type.name;
@@ -249,6 +295,9 @@ function createTailorDBField(type, options, fields, values) {
 		vector() {
 			return cloneWith({ vector: true });
 		},
+		default(value) {
+			return cloneWith({ default: value });
+		},
 		hooks(hooks) {
 			return cloneWith({ hooks });
 		},
@@ -256,22 +305,20 @@ function createTailorDBField(type, options, fields, values) {
 			return cloneWith({ serial: config });
 		},
 		clone(cloneOptions) {
+			if (this._metadata.validate?.length && cloneOptions?.array !== void 0 && cloneOptions.array !== (this._metadata.array === true)) throw new Error("Cannot change the array option on a field with custom validation");
 			let clonedFields = fields;
 			if (fields) {
 				const cloned = {};
 				for (const [key, field] of Object.entries(fields)) cloned[key] = field.clone();
 				clonedFields = cloned;
 			}
-			const clonedField = createTailorDBField(type, options, clonedFields, values);
+			const clonedField = createTailorDBFieldRuntime(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);
-			}
+			if (_rawRelation) clonedField._setRawRelation(cloneDeep(_rawRelation));
 			return clonedField;
 		},
 		_setRawRelation(relation) {
@@ -360,7 +407,7 @@ function date(options) {
 }
 /**
 * Create a datetime field (date and time).
-* Format: ISO 8601 "yyyy-MM-ddTHH:mm:ssZ"
+* Format: ISO 8601, such as "yyyy-MM-ddTHH:mm:ssZ" or "yyyy-MM-ddTHH:mm:ss+09:00"
 * @param options - Field configuration options
 * @returns A datetime field
 * @example db.datetime()
@@ -416,6 +463,16 @@ function createTailorDBType(name, fields, options) {
 	const _permissions = {};
 	let _files = {};
 	const _plugins = [];
+	let _typeHook;
+	let _typeValidate;
+	const _definedMethods = /* @__PURE__ */ new Set();
+	if (options.description !== void 0) _definedMethods.add("description");
+	function runMethodOnce(method, action) {
+		if (_definedMethods.has(method)) throw new Error(`.${method}() has already been set`);
+		const result = action();
+		_definedMethods.add(method);
+		return result;
+	}
 	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;
@@ -441,61 +498,64 @@ function createTailorDBType(name, fields, options) {
 				settings: _settings,
 				permissions: _permissions,
 				files: _files,
-				...Object.keys(indexes).length > 0 && { indexes }
+				...Object.keys(indexes).length > 0 && { indexes },
+				..._typeHook && { typeHook: _typeHook },
+				..._typeValidate && { typeValidate: _typeValidate }
 			};
 		},
-		hooks(hooks) {
-			Object.entries(hooks).forEach(([fieldName, fieldHooks]) => {
-				const field = this.fields[fieldName];
-				if (field === void 0) throw new Error(`field not found: ${fieldName}`);
-				this.fields[fieldName] = field.hooks(fieldHooks);
+		hooks(hook) {
+			return runMethodOnce("hooks", () => {
+				_typeHook = hook;
+				return this;
 			});
-			return this;
 		},
-		validate(validators) {
-			Object.entries(validators).forEach(([fieldName, fieldValidators]) => {
-				const field = this.fields[fieldName];
-				const validators = fieldValidators;
-				const isValidateConfig = (v) => {
-					return Array.isArray(v) && v.length === 2 && typeof v[1] === "string";
-				};
-				let updatedField;
-				if (Array.isArray(validators)) if (isValidateConfig(validators)) updatedField = field.validate(validators);
-				else updatedField = field.validate(...validators);
-				else updatedField = field.validate(validators);
-				this.fields[fieldName] = updatedField;
+		validate(fn) {
+			return runMethodOnce("validate", () => {
+				_typeValidate = fn;
+				return this;
 			});
-			return this;
 		},
 		features(features) {
-			_settings = {
-				..._settings,
-				...features
-			};
-			return this;
+			return runMethodOnce("features", () => {
+				_settings = {
+					..._settings,
+					...features
+				};
+				return this;
+			});
 		},
 		indexes(...indexes) {
-			_indexes = indexes;
-			return this;
+			return runMethodOnce("indexes", () => {
+				_indexes = indexes;
+				return this;
+			});
 		},
 		files(files) {
-			_files = files;
-			return this;
+			return runMethodOnce("files", () => {
+				_files = files;
+				return this;
+			});
 		},
 		permission(permission) {
-			const ret = this;
-			_permissions.record = permission;
-			return ret;
+			return runMethodOnce("permission", () => {
+				const ret = this;
+				_permissions.record = permission;
+				return ret;
+			});
 		},
 		gqlPermission(permission) {
-			const ret = this;
-			_permissions.gql = permission;
-			return ret;
+			return runMethodOnce("gqlPermission", () => {
+				const ret = this;
+				_permissions.gql = permission;
+				return ret;
+			});
 		},
 		description(description) {
-			_description = description;
-			this._description = description;
-			return this;
+			return runMethodOnce("description", () => {
+				_description = description;
+				this._description = description;
+				return this;
+			});
 		},
 		pickFields(keys, options) {
 			const result = {};
@@ -525,7 +585,7 @@ function createTailorDBType(name, fields, options) {
 	}, "tailordb-type");
 }
 const idField = uuid();
-function dbType(name, fieldsOrDescription, fields) {
+function dbTable(name, fieldsOrDescription, fields) {
 	const typeName = Array.isArray(name) ? name[0] : name;
 	const pluralForm = Array.isArray(name) ? name[1] : void 0;
 	let description;
@@ -542,9 +602,9 @@ function dbType(name, fieldsOrDescription, fields) {
 		description
 	});
 }
-/** TailorDB schema builder utilities for defining types and fields. */
+/** TailorDB schema builder utilities for defining tables and fields. */
 const db = {
-	type: dbType,
+	table: dbTable,
 	uuid,
 	string,
 	bool,
@@ -558,23 +618,22 @@ const db = {
 	object,
 	fields: { 
 	/**
-	* Creates standard timestamp fields (createdAt, updatedAt) with auto-hooks.
-	* createdAt is set on create, updatedAt is set on update.
-	* A user-specified createdAt is respected when provided (e.g. seeding historical
-	* records); the current time is used only when the value is omitted.
+	* Creates standard timestamp fields (createdAt, updatedAt) with automatic defaults.
+	* Both fields default to the current time on create. updatedAt is also refreshed on update.
+	* User-specified values are respected when provided (e.g. seeding historical records).
 	* @returns An object with createdAt and updatedAt fields
 	* @example
-	* const model = db.type("Model", {
+	* const model = db.table("Model", {
 	*   name: db.string(),
 	*   ...db.fields.timestamps(),
 	* });
 	*/
 timestamps: () => ({
-		createdAt: datetime().hooks({ create: ({ value }) => value ?? /* @__PURE__ */ new Date() }).description("Record creation timestamp"),
-		updatedAt: datetime({ optional: true }).hooks({ update: () => /* @__PURE__ */ new Date() }).description("Record last update timestamp")
+		createdAt: datetime().default("now").description("Record creation timestamp"),
+		updatedAt: datetime().default("now").hooks({ update: ({ input, now }) => input ?? now }).description("Record update timestamp")
 	}) }
 };
 
 //#endregion
-export { db as t };
-//# sourceMappingURL=schema-BhkpP5Hw.mjs.map
+export { parseInternal as i, mapAllowedValues as n, parseInputFields as r, db as t };
+//# sourceMappingURL=schema--xYWRGfe.mjs.map