@tailor-platform/sdk 2.3.0 → 2.5.0

package/dist/schema--xYWRGfe.mjs

@@ -1,639 +0,0 @@
-import { t as brandValue } from "./brand-Eo4pLXPJ.mjs";
-import { cloneDeep } from "es-toolkit";
-
-//#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>[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+)?$/
-};
-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 "nested": {
-			if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) {
-				issues.push({
-					message: `Expected an object: received ${String(value)}`,
-					path
-				});
-				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.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: "Expected an array",
-				path
-			});
-			return false;
-		}
-		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 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,
-			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
-		});
-	}
-	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$1({
-				value: args.value,
-				data: args.data,
-				invoker: args.invoker,
-				pathArray: []
-			});
-		},
-		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 });
-		},
-		default(value) {
-			return cloneWith({ default: value });
-		},
-		hooks(hooks) {
-			return cloneWith({ hooks });
-		},
-		serial(config) {
-			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 = 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) clonedField._setRawRelation(cloneDeep(_rawRelation));
-			return clonedField;
-		},
-		_setRawRelation(relation) {
-			_rawRelation = relation;
-		}
-	};
-	return field;
-}
-const createField = createTailorDBField;
-/**
-* Create a UUID field.
-* @param options - Field configuration options
-* @returns A UUID field
-* @example db.uuid()
-* @example db.uuid({ optional: true })
-*/
-function uuid(options) {
-	return createField("uuid", options);
-}
-/**
-* Create a string field.
-* @param options - Field configuration options
-* @returns A string field
-* @example db.string()
-* @example db.string({ optional: true })
-*/
-function string(options) {
-	return createField("string", options);
-}
-/**
-* Create a boolean field.
-* Note: The method name is `bool` but creates a `boolean` type field.
-* @param options - Field configuration options
-* @returns A boolean field
-* @example db.bool()
-* @example db.bool({ optional: true })
-*/
-function bool(options) {
-	return createField("boolean", options);
-}
-/**
-* Create an integer field.
-* @param options - Field configuration options
-* @returns An integer field
-* @example db.int()
-* @example db.int({ optional: true })
-*/
-function int(options) {
-	return createField("integer", options);
-}
-/**
-* Create a float (decimal number) field.
-* @param options - Field configuration options
-* @returns A float field
-* @example db.float()
-* @example db.float({ optional: true })
-*/
-function float(options) {
-	return createField("float", options);
-}
-/**
-* Create a decimal field (stored as string for precision).
-* @param options - Field configuration options including optional scale (0-12)
-* @returns A decimal field
-* @example db.decimal()
-* @example db.decimal({ scale: 2 })
-* @example db.decimal({ scale: 2, optional: true })
-*/
-function decimal(options) {
-	if (options?.scale !== void 0) {
-		if (!Number.isInteger(options.scale) || options.scale < 0 || options.scale > 12) throw new Error("scale must be an integer between 0 and 12");
-	}
-	const field = createField("decimal", options);
-	if (options?.scale !== void 0) field._metadata.scale = options.scale;
-	return field;
-}
-/**
-* Create a date field (date only, no time component).
-* Format: "yyyy-MM-dd"
-* @param options - Field configuration options
-* @returns A date field
-* @example db.date()
-*/
-function date(options) {
-	return createField("date", options);
-}
-/**
-* Create a datetime field (date and time).
-* 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()
-*/
-function datetime(options) {
-	return createField("datetime", options);
-}
-/**
-* Create a time field (time only, no date component).
-* Format: "HH:mm"
-* @param options - Field configuration options
-* @returns A time field
-* @example db.time()
-*/
-function time(options) {
-	return createField("time", options);
-}
-/**
-* Create an enum field with a fixed set of allowed string values.
-* @param values - Array of allowed string values, or array of `{ value, description }` objects
-* @param options - Field configuration options
-* @returns An enum field
-* @example db.enum(["active", "inactive", "suspended"])
-* @example db.enum(["small", "medium", "large"], { optional: true })
-*/
-function _enum(values, options) {
-	return createField("enum", options, void 0, values);
-}
-/**
-* Create a nested object field with sub-fields.
-* @param fields - Record of nested field definitions
-* @param options - Field configuration options
-* @returns A nested object field
-* @example db.object({ street: db.string(), city: db.string(), zip: db.string() })
-* @example db.object({ name: db.string() }, { optional: true })
-*/
-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 = [];
-	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;
-	}
-	return brandValue({
-		name,
-		fields: { ...fields },
-		_output: null,
-		_description,
-		get metadata() {
-			const indexes = {};
-			if (_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 },
-				..._typeHook && { typeHook: _typeHook },
-				..._typeValidate && { typeValidate: _typeValidate }
-			};
-		},
-		hooks(hook) {
-			return runMethodOnce("hooks", () => {
-				_typeHook = hook;
-				return this;
-			});
-		},
-		validate(fn) {
-			return runMethodOnce("validate", () => {
-				_typeValidate = fn;
-				return this;
-			});
-		},
-		features(features) {
-			return runMethodOnce("features", () => {
-				_settings = {
-					..._settings,
-					...features
-				};
-				return this;
-			});
-		},
-		indexes(...indexes) {
-			return runMethodOnce("indexes", () => {
-				_indexes = indexes;
-				return this;
-			});
-		},
-		files(files) {
-			return runMethodOnce("files", () => {
-				_files = files;
-				return this;
-			});
-		},
-		permission(permission) {
-			return runMethodOnce("permission", () => {
-				const ret = this;
-				_permissions.record = permission;
-				return ret;
-			});
-		},
-		gqlPermission(permission) {
-			return runMethodOnce("gqlPermission", () => {
-				const ret = this;
-				_permissions.gql = permission;
-				return ret;
-			});
-		},
-		description(description) {
-			return runMethodOnce("description", () => {
-				_description = description;
-				this._description = description;
-				return this;
-			});
-		},
-		pickFields(keys, options) {
-			const result = {};
-			for (const key of keys) {
-				const field = this.fields[key];
-				if (options) result[key] = field.clone(options);
-				else result[key] = field;
-			}
-			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;
-		}
-	}, "tailordb-type");
-}
-const idField = uuid();
-function dbTable(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
-	});
-}
-/** TailorDB schema builder utilities for defining tables and fields. */
-const db = {
-	table: dbTable,
-	uuid,
-	string,
-	bool,
-	int,
-	float,
-	decimal,
-	date,
-	datetime,
-	time,
-	enum: _enum,
-	object,
-	fields: { 
-	/**
-	* 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.table("Model", {
-	*   name: db.string(),
-	*   ...db.fields.timestamps(),
-	* });
-	*/
-timestamps: () => ({
-		createdAt: datetime().default("now").description("Record creation timestamp"),
-		updatedAt: datetime().default("now").hooks({ update: ({ input, now }) => input ?? now }).description("Record update timestamp")
-	}) }
-};
-
-//#endregion
-export { parseInternal as i, mapAllowedValues as n, parseInputFields as r, db as t };
-//# sourceMappingURL=schema--xYWRGfe.mjs.map