@tailor-platform/sdk 1.12.0 → 1.14.0

package/dist/{update-B_W-UQnS.mjs → update-BnKKm4aR.mjs}

@@ -3749,13 +3749,19 @@ function generateIdpUserSeedCall(hasIdpUser) {
 /**
 * Generates the exec.mjs script content using testExecScript API for TailorDB types
 * and GraphQL mutation for _User (IdP managed)
-* @param machineUserName - Machine user name for token retrieval
+* @param defaultMachineUserName - Default machine user name from generator config (can be overridden at runtime)
 * @param relativeConfigPath - Config path relative to exec script
 * @param namespaceConfigs - Namespace configurations with types and dependencies
 * @param hasIdpUser - Whether _User is included
 * @returns exec.mjs file contents
 */
-function generateExecScript(machineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser) {
+function generateExecScript(defaultMachineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser) {
+	const namespaceEntitiesEntries = namespaceConfigs.map(({ namespace, types }) => {
+		return `      "${namespace}": [\n${types.map((e) => `        "${e}",`).join("\n")}\n      ]`;
+	}).join(",\n");
+	const namespaceDepsEntries = namespaceConfigs.map(({ namespace, dependencies }) => {
+		return `      "${namespace}": {\n${Object.entries(dependencies).map(([type, deps]) => `        "${type}": [${deps.map((d) => `"${d}"`).join(", ")}]`).join(",\n")}\n      }`;
+	}).join(",\n");
 	return ml`
     import { readFileSync } from "node:fs";
     import { join } from "node:path";
@@ -3776,6 +3782,7 @@ function generateExecScript(machineUserName, relativeConfigPath, namespaceConfig
     // Parse command-line arguments
     const { values, positionals } = parseArgs({
       options: {
+        "machine-user": { type: "string", short: "m" },
         namespace: { type: "string", short: "n" },
         "skip-idp": { type: "boolean", default: false },
         truncate: { type: "boolean", default: false },
@@ -3791,15 +3798,16 @@ function generateExecScript(machineUserName, relativeConfigPath, namespaceConfig
     Usage: node exec.mjs [options] [types...]
 
     Options:
-      -n, --namespace <ns> Process all types in specified namespace (excludes _User)
-      --skip-idp           Skip IdP user (_User) entity
-      --truncate           Truncate tables before seeding
-      --yes                Skip confirmation prompts (for truncate)
-      -p, --profile <name> Workspace profile name
-      -h, --help           Show help
+      -m, --machine-user <name> Machine user name for authentication (required if not configured)
+      -n, --namespace <ns>      Process all types in specified namespace (excludes _User)
+      --skip-idp                Skip IdP user (_User) entity
+      --truncate                Truncate tables before seeding
+      --yes                     Skip confirmation prompts (for truncate)
+      -p, --profile <name>      Workspace profile name
+      -h, --help                Show help
 
     Examples:
-      node exec.mjs                                     # Process all types (default)
+      node exec.mjs -m admin                            # Process all types with machine user
       node exec.mjs --namespace <namespace>             # Process tailordb namespace only (no _User)
       node exec.mjs User Order                          # Process specific types only
       node exec.mjs --skip-idp                          # Process all except _User
@@ -3829,16 +3837,22 @@ function generateExecScript(machineUserName, relativeConfigPath, namespaceConfig
     const configDir = import.meta.dirname;
     const configPath = join(configDir, "${relativeConfigPath}");
 
+    // Determine machine user name (CLI argument takes precedence over config default)
+    const defaultMachineUser = ${defaultMachineUserName ? `"${defaultMachineUserName}"` : "undefined"};
+    const machineUserName = values["machine-user"] || defaultMachineUser;
+
+    if (!machineUserName) {
+      console.error(styleText("red", "Error: Machine user name is required."));
+      console.error(styleText("yellow", "Specify --machine-user <name> or configure machineUserName in generator options."));
+      process.exit(1);
+    }
+
     // Entity configuration
     const namespaceEntities = {
-${namespaceConfigs.map(({ namespace, types }) => {
-		return `      "${namespace}": [\n${types.map((e) => `        "${e}",`).join("\n")}\n      ]`;
-	}).join(",\n")}
+${namespaceEntitiesEntries}
     };
     const namespaceDeps = {
-${namespaceConfigs.map(({ namespace, dependencies }) => {
-		return `      "${namespace}": {\n${Object.entries(dependencies).map(([type, deps]) => `        "${type}": [${deps.map((d) => `"${d}"`).join(", ")}]`).join(",\n")}\n      }`;
-	}).join(",\n")}
+${namespaceDepsEntries}
     };
     const entities = Object.values(namespaceEntities).flat();
     const hasIdpUser = ${String(hasIdpUser)};
@@ -3963,7 +3977,7 @@ ${namespaceConfigs.map(({ namespace, dependencies }) => {
 
     // Get machine user token
     const tokenInfo = await getMachineUserToken({
-      name: "${machineUserName}",
+      name: machineUserName,
       configPath,
       profile: values.profile,
     });
@@ -4071,7 +4085,7 @@ ${namespaceConfigs.map(({ namespace, dependencies }) => {
           arg: JSON.stringify({ data: chunk.data, order: chunk.order }),
           invoker: {
             namespace: authNamespace,
-            machineUserName: "${machineUserName}",
+            machineUserName,
           },
         });
 
@@ -4251,13 +4265,11 @@ function createSeedGenerator(options) {
 					content: generateIdpUserSchemaFile(idpUser.schema.usernameField, idpUser.schema.userTypeName)
 				});
 			}
-			if (options.machineUserName) {
-				const relativeConfigPath = path.relative(options.distPath, configPath);
-				files.push({
-					path: path.join(options.distPath, "exec.mjs"),
-					content: generateExecScript(options.machineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser)
-				});
-			}
+			const relativeConfigPath = path.relative(options.distPath, configPath);
+			files.push({
+				path: path.join(options.distPath, "exec.mjs"),
+				content: generateExecScript(options.machineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser)
+			});
 			return { files };
 		}
 	};
@@ -7595,6 +7607,16 @@ function formatDiffChange(change) {
 			const after = change.after;
 			return `  ~ ${change.fieldName}: ${formatFieldModification(before, after)}`;
 		}
+		case "index_added": return `  + [Index] ${change.indexName}`;
+		case "index_removed": return `  - [Index] ${change.indexName}`;
+		case "index_modified": return `  ~ [Index] ${change.indexName}: ${change.reason ?? "modified"}`;
+		case "file_added": return `  + [File] ${change.fieldName}`;
+		case "file_removed": return `  - [File] ${change.fieldName}`;
+		case "file_modified": return `  ~ [File] ${change.fieldName}: ${change.reason ?? "modified"}`;
+		case "relationship_added": return `  + [Relationship${change.relationshipType ? ` (${change.relationshipType})` : ""}] ${change.relationshipName}`;
+		case "relationship_removed": return `  - [Relationship${change.relationshipType ? ` (${change.relationshipType})` : ""}] ${change.relationshipName}`;
+		case "relationship_modified": return `  ~ [Relationship${change.relationshipType ? ` (${change.relationshipType})` : ""}] ${change.relationshipName}: ${change.reason ?? "modified"}`;
+		case "permission_modified": return `  ~ [Permission] ${change.reason ?? "modified"}`;
 		default: return `  ? ${change.typeName}.${change.fieldName ?? ""}`;
 	}
 }
@@ -7623,10 +7645,22 @@ function formatFieldModification(before, after) {
 	if (Boolean(before.array) !== Boolean(after.array)) changes.push(`array: ${before.array ?? false} → ${after.array ?? false}`);
 	if (Boolean(before.index) !== Boolean(after.index)) changes.push(`index: ${before.index ?? false} → ${after.index ?? false}`);
 	if (Boolean(before.unique) !== Boolean(after.unique)) changes.push(`unique: ${before.unique ?? false} → ${after.unique ?? false}`);
+	if (Boolean(before.vector) !== Boolean(after.vector)) changes.push(`vector: ${before.vector ?? false} → ${after.vector ?? false}`);
 	const beforeAllowed = before.allowedValues ?? [];
 	const afterAllowed = after.allowedValues ?? [];
-	const afterSet = new Set(afterAllowed);
-	if (beforeAllowed.length !== afterAllowed.length || beforeAllowed.some((v) => !afterSet.has(v))) changes.push(`allowedValues: [${beforeAllowed.join(", ")}] → [${afterAllowed.join(", ")}]`);
+	const afterSet = new Set(afterAllowed.map((v) => v.value));
+	if (beforeAllowed.length !== afterAllowed.length || beforeAllowed.some((v) => !afterSet.has(v.value))) {
+		const beforeValues = beforeAllowed.map((v) => v.value).join(", ");
+		const afterValues = afterAllowed.map((v) => v.value).join(", ");
+		changes.push(`allowedValues: [${beforeValues}] → [${afterValues}]`);
+	}
+	const beforeHooks = before.hooks;
+	const afterHooks = after.hooks;
+	if ((beforeHooks?.create?.expr ?? "") !== (afterHooks?.create?.expr ?? "") || (beforeHooks?.update?.expr ?? "") !== (afterHooks?.update?.expr ?? "")) changes.push("hooks modified");
+	const beforeValidate = before.validate ?? [];
+	const afterValidate = after.validate ?? [];
+	if (beforeValidate.length !== afterValidate.length) changes.push(`validations: ${beforeValidate.length} → ${afterValidate.length}`);
+	if (Boolean(before.serial) !== Boolean(after.serial)) changes.push(`serial: ${before.serial ? "enabled" : "disabled"} → ${after.serial ? "enabled" : "disabled"}`);
 	return changes.join(", ");
 }
 /**
@@ -7643,44 +7677,34 @@ function formatBreakingChanges(breakingChanges) {
 	}
 	return lines.join("\n");
 }
+const DIFF_CHANGE_LABELS = {
+	type_added: "type(s) added",
+	type_removed: "type(s) removed",
+	type_modified: "type(s) modified",
+	field_added: "field(s) added",
+	field_removed: "field(s) removed",
+	field_modified: "field(s) modified",
+	index_added: "index(es) added",
+	index_removed: "index(es) removed",
+	index_modified: "index(es) modified",
+	file_added: "file field(s) added",
+	file_removed: "file field(s) removed",
+	file_modified: "file field(s) modified",
+	relationship_added: "relationship(s) added",
+	relationship_removed: "relationship(s) removed",
+	relationship_modified: "relationship(s) modified",
+	permission_modified: "permission(s) modified"
+};
 /**
 * Format a summary of the migration diff
 * @param {MigrationDiff} diff - Migration diff to summarize
 * @returns {string} Formatted summary string
 */
 function formatDiffSummary(diff) {
-	const stats = {
-		typesAdded: 0,
-		typesRemoved: 0,
-		fieldsAdded: 0,
-		fieldsRemoved: 0,
-		fieldsModified: 0
-	};
-	for (const change of diff.changes) switch (change.kind) {
-		case "type_added":
-			stats.typesAdded++;
-			break;
-		case "type_removed":
-			stats.typesRemoved++;
-			break;
-		case "field_added":
-			stats.fieldsAdded++;
-			break;
-		case "field_removed":
-			stats.fieldsRemoved++;
-			break;
-		case "field_modified":
-			stats.fieldsModified++;
-			break;
-	}
-	const parts = [];
-	if (stats.typesAdded > 0) parts.push(`${stats.typesAdded} type(s) added`);
-	if (stats.typesRemoved > 0) parts.push(`${stats.typesRemoved} type(s) removed`);
-	if (stats.fieldsAdded > 0) parts.push(`${stats.fieldsAdded} field(s) added`);
-	if (stats.fieldsRemoved > 0) parts.push(`${stats.fieldsRemoved} field(s) removed`);
-	if (stats.fieldsModified > 0) parts.push(`${stats.fieldsModified} field(s) modified`);
-	if (parts.length === 0) return "No changes";
-	return parts.join(", ");
+	const stats = {};
+	for (const change of diff.changes) stats[change.kind] = (stats[change.kind] ?? 0) + 1;
+	const parts = Object.keys(stats).map((kind) => `${stats[kind]} ${DIFF_CHANGE_LABELS[kind]}`);
+	return parts.length > 0 ? parts.join(", ") : "No changes";
 }
 
 //#endregion
@@ -7763,12 +7787,79 @@ function createSnapshotFieldConfig(field) {
 	if (field.config.array) config.array = true;
 	if (field.config.index) config.index = true;
 	if (field.config.unique) config.unique = true;
-	if (field.config.allowedValues && field.config.allowedValues.length > 0) config.allowedValues = field.config.allowedValues.map((v) => v.value);
+	if (field.config.allowedValues && field.config.allowedValues.length > 0) config.allowedValues = field.config.allowedValues.map((v) => ({
+		value: v.value,
+		...v.description && { description: v.description }
+	}));
 	if (field.config.foreignKey) {
 		config.foreignKey = true;
 		if (field.config.foreignKeyType) config.foreignKeyType = field.config.foreignKeyType;
 		if (field.config.foreignKeyField) config.foreignKeyField = field.config.foreignKeyField;
 	}
+	if (field.config.description) config.description = field.config.description;
+	if (field.config.vector) config.vector = true;
+	if (field.config.hooks) {
+		config.hooks = {};
+		if (field.config.hooks.create) config.hooks.create = { expr: field.config.hooks.create.expr };
+		if (field.config.hooks.update) config.hooks.update = { expr: field.config.hooks.update.expr };
+	}
+	if (field.config.validate && field.config.validate.length > 0) config.validate = field.config.validate.map((v) => ({
+		script: { expr: v.script.expr },
+		errorMessage: v.errorMessage
+	}));
+	if (field.config.serial) config.serial = {
+		start: field.config.serial.start,
+		...field.config.serial.maxValue !== void 0 && { maxValue: field.config.serial.maxValue },
+		...field.config.serial.format && { format: field.config.serial.format }
+	};
+	if (field.config.fields && Object.keys(field.config.fields).length > 0) {
+		config.fields = {};
+		for (const [nestedName, nestedConfig] of Object.entries(field.config.fields)) config.fields[nestedName] = createSnapshotFieldConfigFromOperatorConfig(nestedConfig);
+	}
+	return config;
+}
+/**
+* Create a snapshot field config from an OperatorFieldConfig (for nested fields)
+* @param {import("@/parser/service/tailordb/types").OperatorFieldConfig} fieldConfig - Field configuration
+* @returns {SnapshotFieldConfig} Snapshot field configuration
+*/
+function createSnapshotFieldConfigFromOperatorConfig(fieldConfig) {
+	const config = {
+		type: fieldConfig.type,
+		required: fieldConfig.required !== false
+	};
+	if (fieldConfig.array) config.array = true;
+	if (fieldConfig.index) config.index = true;
+	if (fieldConfig.unique) config.unique = true;
+	if (fieldConfig.allowedValues && fieldConfig.allowedValues.length > 0) config.allowedValues = fieldConfig.allowedValues.map((v) => ({
+		value: v.value,
+		...v.description && { description: v.description }
+	}));
+	if (fieldConfig.foreignKey) {
+		config.foreignKey = true;
+		if (fieldConfig.foreignKeyType) config.foreignKeyType = fieldConfig.foreignKeyType;
+		if (fieldConfig.foreignKeyField) config.foreignKeyField = fieldConfig.foreignKeyField;
+	}
+	if (fieldConfig.description) config.description = fieldConfig.description;
+	if (fieldConfig.vector) config.vector = true;
+	if (fieldConfig.hooks) {
+		config.hooks = {};
+		if (fieldConfig.hooks.create) config.hooks.create = { expr: fieldConfig.hooks.create.expr };
+		if (fieldConfig.hooks.update) config.hooks.update = { expr: fieldConfig.hooks.update.expr };
+	}
+	if (fieldConfig.validate && fieldConfig.validate.length > 0) config.validate = fieldConfig.validate.map((v) => ({
+		script: { expr: v.script.expr },
+		errorMessage: v.errorMessage
+	}));
+	if (fieldConfig.serial) config.serial = {
+		start: fieldConfig.serial.start,
+		...fieldConfig.serial.maxValue !== void 0 && { maxValue: fieldConfig.serial.maxValue },
+		...fieldConfig.serial.format && { format: fieldConfig.serial.format }
+	};
+	if (fieldConfig.fields && Object.keys(fieldConfig.fields).length > 0) {
+		config.fields = {};
+		for (const [nestedName, nestedConfig] of Object.entries(fieldConfig.fields)) config.fields[nestedName] = createSnapshotFieldConfigFromOperatorConfig(nestedConfig);
+	}
 	return config;
 }
 /**
@@ -7807,9 +7898,56 @@ function createSnapshotType(type) {
 		};
 	}
 	if (type.files && Object.keys(type.files).length > 0) snapshotType.files = { ...type.files };
+	if (Object.keys(type.forwardRelationships).length > 0) {
+		snapshotType.forwardRelationships = {};
+		for (const [relName, rel] of Object.entries(type.forwardRelationships)) snapshotType.forwardRelationships[relName] = {
+			targetType: rel.targetType,
+			targetField: rel.targetField,
+			sourceField: rel.sourceField,
+			isArray: rel.isArray,
+			description: rel.description
+		};
+	}
+	if (Object.keys(type.backwardRelationships).length > 0) {
+		snapshotType.backwardRelationships = {};
+		for (const [relName, rel] of Object.entries(type.backwardRelationships)) snapshotType.backwardRelationships[relName] = {
+			targetType: rel.targetType,
+			targetField: rel.targetField,
+			sourceField: rel.sourceField,
+			isArray: rel.isArray,
+			description: rel.description
+		};
+	}
+	if (type.permissions.record || type.permissions.gql) {
+		snapshotType.permissions = {};
+		if (type.permissions.record) snapshotType.permissions.record = {
+			create: type.permissions.record.create.map(convertActionPermission),
+			read: type.permissions.record.read.map(convertActionPermission),
+			update: type.permissions.record.update.map(convertActionPermission),
+			delete: type.permissions.record.delete.map(convertActionPermission)
+		};
+		if (type.permissions.gql) snapshotType.permissions.gql = type.permissions.gql.map((policy) => ({
+			conditions: policy.conditions,
+			actions: policy.actions,
+			permit: policy.permit,
+			...policy.description && { description: policy.description }
+		}));
+	}
 	return snapshotType;
 }
 /**
+* Convert an action permission to snapshot format
+* @param {StandardActionPermission<"record">} permission - Action permission
+* @returns {SnapshotActionPermission} Snapshot action permission
+*/
+function convertActionPermission(permission) {
+	return {
+		conditions: permission.conditions,
+		permit: permission.permit,
+		...permission.description && { description: permission.description }
+	};
+}
+/**
 * Create a schema snapshot from local type definitions
 * @param {Record<string, TailorDBType>} types - Local type definitions
 * @param {string} namespace - Namespace for the snapshot
@@ -7928,6 +8066,95 @@ function applyDiffToSnapshot(snapshot, diff) {
 				};
 			}
 			break;
+		case "index_added":
+		case "index_modified":
+			if (types[change.typeName] && change.indexName) types[change.typeName] = {
+				...types[change.typeName],
+				indexes: {
+					...types[change.typeName].indexes,
+					[change.indexName]: change.after
+				}
+			};
+			break;
+		case "index_removed":
+			if (types[change.typeName] && change.indexName && types[change.typeName].indexes) {
+				const { [change.indexName]: _, ...remainingIndexes } = types[change.typeName].indexes;
+				types[change.typeName] = {
+					...types[change.typeName],
+					indexes: Object.keys(remainingIndexes).length > 0 ? remainingIndexes : void 0
+				};
+			}
+			break;
+		case "file_added":
+		case "file_modified":
+			if (types[change.typeName] && change.fieldName) types[change.typeName] = {
+				...types[change.typeName],
+				files: {
+					...types[change.typeName].files,
+					[change.fieldName]: change.after
+				}
+			};
+			break;
+		case "file_removed":
+			if (types[change.typeName] && change.fieldName && types[change.typeName].files) {
+				const { [change.fieldName]: _, ...remainingFiles } = types[change.typeName].files;
+				types[change.typeName] = {
+					...types[change.typeName],
+					files: Object.keys(remainingFiles).length > 0 ? remainingFiles : void 0
+				};
+			}
+			break;
+		case "relationship_added":
+		case "relationship_modified":
+			if (types[change.typeName] && change.relationshipName) {
+				const rel = change.after;
+				if ((change.relationshipType ?? (types[change.typeName].forwardRelationships?.[change.relationshipName] ? "forward" : types[change.typeName].backwardRelationships?.[change.relationshipName] ? "backward" : "forward")) === "forward") types[change.typeName] = {
+					...types[change.typeName],
+					forwardRelationships: {
+						...types[change.typeName].forwardRelationships,
+						[change.relationshipName]: rel
+					}
+				};
+				else types[change.typeName] = {
+					...types[change.typeName],
+					backwardRelationships: {
+						...types[change.typeName].backwardRelationships,
+						[change.relationshipName]: rel
+					}
+				};
+			}
+			break;
+		case "relationship_removed":
+			if (types[change.typeName] && change.relationshipName) {
+				const type = types[change.typeName];
+				const targetType = change.relationshipType ?? (type.forwardRelationships?.[change.relationshipName] ? "forward" : type.backwardRelationships?.[change.relationshipName] ? "backward" : null);
+				if (targetType === "forward" && type.forwardRelationships?.[change.relationshipName]) {
+					const { [change.relationshipName]: _, ...remaining } = type.forwardRelationships;
+					types[change.typeName] = {
+						...type,
+						forwardRelationships: Object.keys(remaining).length > 0 ? remaining : void 0
+					};
+				} else if (targetType === "backward" && type.backwardRelationships?.[change.relationshipName]) {
+					const { [change.relationshipName]: _, ...remaining } = type.backwardRelationships;
+					types[change.typeName] = {
+						...type,
+						backwardRelationships: Object.keys(remaining).length > 0 ? remaining : void 0
+					};
+				}
+			}
+			break;
+		case "permission_modified":
+			if (types[change.typeName] && change.after) {
+				const after = change.after;
+				types[change.typeName] = {
+					...types[change.typeName],
+					permissions: {
+						record: after.recordPermission,
+						gql: after.gqlPermission
+					}
+				};
+			}
+			break;
 	}
 	return {
 		...snapshot,
@@ -7979,15 +8206,51 @@ function areFieldsDifferent(oldField, newField) {
 		"array",
 		"index",
 		"unique",
-		"foreignKey"
+		"foreignKey",
+		"vector"
 	]) if ((oldField[prop] ?? false) !== (newField[prop] ?? false)) return true;
 	if (oldField.foreignKeyType !== newField.foreignKeyType) return true;
 	if (oldField.foreignKeyField !== newField.foreignKeyField) return true;
+	if ((oldField.description ?? "") !== (newField.description ?? "")) return true;
 	const oldAllowed = oldField.allowedValues ?? [];
 	const newAllowed = newField.allowedValues ?? [];
 	if (oldAllowed.length !== newAllowed.length) return true;
-	const newAllowedSet = new Set(newAllowed);
-	if (oldAllowed.some((v) => !newAllowedSet.has(v))) return true;
+	const newAllowedMap = new Map(newAllowed.map((v) => [v.value, v.description]));
+	for (const v of oldAllowed) {
+		if (!newAllowedMap.has(v.value)) return true;
+		if ((v.description ?? "") !== (newAllowedMap.get(v.value) ?? "")) return true;
+	}
+	const oldHooks = oldField.hooks;
+	const newHooks = newField.hooks;
+	if (Boolean(oldHooks) !== Boolean(newHooks)) return true;
+	if (oldHooks && newHooks) {
+		if ((oldHooks.create?.expr ?? "") !== (newHooks.create?.expr ?? "")) return true;
+		if ((oldHooks.update?.expr ?? "") !== (newHooks.update?.expr ?? "")) return true;
+	}
+	const oldValidate = oldField.validate ?? [];
+	const newValidate = newField.validate ?? [];
+	if (oldValidate.length !== newValidate.length) return true;
+	for (let i = 0; i < oldValidate.length; i++) {
+		if (oldValidate[i].script.expr !== newValidate[i].script.expr) return true;
+		if (oldValidate[i].errorMessage !== newValidate[i].errorMessage) return true;
+	}
+	const oldSerial = oldField.serial;
+	const newSerial = newField.serial;
+	if (Boolean(oldSerial) !== Boolean(newSerial)) return true;
+	if (oldSerial && newSerial) {
+		if (oldSerial.start !== newSerial.start) return true;
+		if (oldSerial.maxValue !== newSerial.maxValue) return true;
+		if ((oldSerial.format ?? "") !== (newSerial.format ?? "")) return true;
+	}
+	const oldFields = oldField.fields ?? {};
+	const newFields = newField.fields ?? {};
+	const oldFieldNames = Object.keys(oldFields);
+	const newFieldNames = Object.keys(newFields);
+	if (oldFieldNames.length !== newFieldNames.length) return true;
+	for (const fieldName of oldFieldNames) {
+		if (!newFields[fieldName]) return true;
+		if (areFieldsDifferent(oldFields[fieldName], newFields[fieldName])) return true;
+	}
 	return false;
 }
 /**
@@ -8043,7 +8306,9 @@ function isBreakingFieldChange(typeName, fieldName, oldField, newField) {
 	if (oldField && newField && oldField.type === "enum" && newField.type === "enum") {
 		const oldAllowed = oldField.allowedValues ?? [];
 		const newAllowed = newField.allowedValues ?? [];
-		const removedValues = oldAllowed.filter((v) => !newAllowed.includes(v));
+		const oldValues = oldAllowed.map((v) => v.value);
+		const newValuesSet = new Set(newAllowed.map((v) => v.value));
+		const removedValues = oldValues.filter((v) => !newValuesSet.has(v));
 		if (removedValues.length > 0) return {
 			typeName,
 			fieldName,
@@ -8099,29 +8364,35 @@ function compareIndexes(ctx, typeName, oldIndexes, newIndexes) {
 	const oldKeys = new Set(Object.keys(oldIndexes || {}));
 	const newKeys = new Set(Object.keys(newIndexes || {}));
 	for (const indexName of newKeys) if (!oldKeys.has(indexName)) ctx.changes.push({
-		kind: "type_modified",
+		kind: "index_added",
 		typeName,
-		reason: `Index "${indexName}" added`,
-		before: { indexes: oldIndexes },
-		after: { indexes: newIndexes }
+		indexName,
+		after: newIndexes[indexName]
 	});
 	for (const indexName of oldKeys) if (!newKeys.has(indexName)) ctx.changes.push({
-		kind: "type_modified",
+		kind: "index_removed",
 		typeName,
-		reason: `Index "${indexName}" removed`,
-		before: { indexes: oldIndexes },
-		after: { indexes: newIndexes }
+		indexName,
+		before: oldIndexes[indexName]
 	});
 	for (const indexName of newKeys) if (oldKeys.has(indexName)) {
 		const oldIndex = oldIndexes[indexName];
 		const newIndex = newIndexes[indexName];
-		if (JSON.stringify(oldIndex.fields.toSorted()) !== JSON.stringify(newIndex.fields.toSorted()) || oldIndex.unique !== newIndex.unique) ctx.changes.push({
-			kind: "type_modified",
-			typeName,
-			reason: `Index "${indexName}" modified`,
-			before: { indexes: oldIndexes },
-			after: { indexes: newIndexes }
-		});
+		const oldFieldsStr = JSON.stringify(oldIndex.fields.toSorted());
+		const newFieldsStr = JSON.stringify(newIndex.fields.toSorted());
+		if (oldFieldsStr !== newFieldsStr || oldIndex.unique !== newIndex.unique) {
+			const reasons = [];
+			if (oldFieldsStr !== newFieldsStr) reasons.push("fields changed");
+			if (oldIndex.unique !== newIndex.unique) reasons.push("unique constraint changed");
+			ctx.changes.push({
+				kind: "index_modified",
+				typeName,
+				indexName,
+				reason: reasons.join(", "),
+				before: oldIndex,
+				after: newIndex
+			});
+		}
 	}
 }
 /**
@@ -8136,26 +8407,102 @@ function compareFiles(ctx, typeName, oldFiles, newFiles) {
 	const oldKeys = new Set(Object.keys(oldFiles || {}));
 	const newKeys = new Set(Object.keys(newFiles || {}));
 	for (const fileName of newKeys) if (!oldKeys.has(fileName)) ctx.changes.push({
-		kind: "type_modified",
+		kind: "file_added",
 		typeName,
-		reason: `File field "${fileName}" added`,
-		before: { files: oldFiles },
-		after: { files: newFiles }
+		fieldName: fileName,
+		after: newFiles[fileName]
 	});
 	for (const fileName of oldKeys) if (!newKeys.has(fileName)) ctx.changes.push({
-		kind: "type_modified",
+		kind: "file_removed",
 		typeName,
-		reason: `File field "${fileName}" removed`,
-		before: { files: oldFiles },
-		after: { files: newFiles }
+		fieldName: fileName,
+		before: oldFiles[fileName]
 	});
 	for (const fileName of newKeys) if (oldKeys.has(fileName)) {
 		if (oldFiles[fileName] !== newFiles[fileName]) ctx.changes.push({
-			kind: "type_modified",
+			kind: "file_modified",
+			typeName,
+			fieldName: fileName,
+			reason: "description changed",
+			before: oldFiles[fileName],
+			after: newFiles[fileName]
+		});
+	}
+}
+/**
+* Compare type-level relationships
+* @param {DiffContext} ctx - Diff context
+* @param {string} typeName - Type name
+* @param relationshipType
+* @param {Record<string, SnapshotRelationship> | undefined} oldRelationships - Previous relationships
+* @param {Record<string, SnapshotRelationship> | undefined} newRelationships - Current relationships
+* @returns {void}
+*/
+function compareRelationships(ctx, typeName, relationshipType, oldRelationships, newRelationships) {
+	const oldKeys = new Set(Object.keys(oldRelationships || {}));
+	const newKeys = new Set(Object.keys(newRelationships || {}));
+	for (const relName of newKeys) if (!oldKeys.has(relName)) ctx.changes.push({
+		kind: "relationship_added",
+		typeName,
+		relationshipName: relName,
+		relationshipType,
+		after: newRelationships[relName]
+	});
+	for (const relName of oldKeys) if (!newKeys.has(relName)) ctx.changes.push({
+		kind: "relationship_removed",
+		typeName,
+		relationshipName: relName,
+		relationshipType,
+		before: oldRelationships[relName]
+	});
+	for (const relName of newKeys) if (oldKeys.has(relName)) {
+		const oldRel = oldRelationships[relName];
+		const newRel = newRelationships[relName];
+		const reasons = [];
+		if (oldRel.targetType !== newRel.targetType) reasons.push("targetType changed");
+		if (oldRel.targetField !== newRel.targetField) reasons.push("targetField changed");
+		if (oldRel.sourceField !== newRel.sourceField) reasons.push("sourceField changed");
+		if (oldRel.isArray !== newRel.isArray) reasons.push("isArray changed");
+		if (reasons.length > 0) ctx.changes.push({
+			kind: "relationship_modified",
+			typeName,
+			relationshipName: relName,
+			relationshipType,
+			reason: reasons.join(", "),
+			before: oldRel,
+			after: newRel
+		});
+	}
+}
+/**
+* Compare type-level permissions
+* @param {DiffContext} ctx - Diff context
+* @param {string} typeName - Type name
+* @param {SnapshotRecordPermission | undefined} oldRecordPerm - Previous record permission
+* @param {SnapshotRecordPermission | undefined} newRecordPerm - Current record permission
+* @param {SnapshotGqlPermission | undefined} oldGqlPerm - Previous GQL permission
+* @param {SnapshotGqlPermission | undefined} newGqlPerm - Current GQL permission
+* @returns {void}
+*/
+function comparePermissions(ctx, typeName, oldRecordPerm, newRecordPerm, oldGqlPerm, newGqlPerm) {
+	const recordPermChanged = JSON.stringify(oldRecordPerm ?? null) !== JSON.stringify(newRecordPerm ?? null);
+	const gqlPermChanged = JSON.stringify(oldGqlPerm ?? null) !== JSON.stringify(newGqlPerm ?? null);
+	if (recordPermChanged || gqlPermChanged) {
+		const reasons = [];
+		if (recordPermChanged) reasons.push("record permission");
+		if (gqlPermChanged) reasons.push("GQL permission");
+		ctx.changes.push({
+			kind: "permission_modified",
 			typeName,
-			reason: `File field "${fileName}" description changed`,
-			before: { files: oldFiles },
-			after: { files: newFiles }
+			reason: `${reasons.join(" and ")} changed`,
+			before: {
+				recordPermission: oldRecordPerm,
+				gqlPermission: oldGqlPerm
+			},
+			after: {
+				recordPermission: newRecordPerm,
+				gqlPermission: newGqlPerm
+			}
 		});
 	}
 }
@@ -8189,6 +8536,9 @@ function compareSnapshots(previous, current) {
 		compareTypeFields(ctx, typeName, prevType, currType);
 		compareIndexes(ctx, typeName, prevType.indexes, currType.indexes);
 		compareFiles(ctx, typeName, prevType.files, currType.files);
+		compareRelationships(ctx, typeName, "forward", prevType.forwardRelationships, currType.forwardRelationships);
+		compareRelationships(ctx, typeName, "backward", prevType.backwardRelationships, currType.backwardRelationships);
+		comparePermissions(ctx, typeName, prevType.permissions?.record, currType.permissions?.record, prevType.permissions?.gql, currType.permissions?.gql);
 	}
 	return {
 		version: SCHEMA_SNAPSHOT_VERSION,
@@ -8294,7 +8644,26 @@ function convertRemoteFieldsToSnapshot(remoteType) {
 			if (remoteField.foreignKeyType) config.foreignKeyType = remoteField.foreignKeyType;
 			if (remoteField.foreignKeyField) config.foreignKeyField = remoteField.foreignKeyField;
 		}
-		if (remoteField.allowedValues && remoteField.allowedValues.length > 0) config.allowedValues = remoteField.allowedValues.map((v) => v.value);
+		if (remoteField.allowedValues && remoteField.allowedValues.length > 0) config.allowedValues = remoteField.allowedValues.map((v) => ({
+			value: v.value,
+			...v.description && { description: v.description }
+		}));
+		if (remoteField.description) config.description = remoteField.description;
+		if (remoteField.vector) config.vector = true;
+		if (remoteField.hooks) {
+			config.hooks = {};
+			if (remoteField.hooks.create?.expr) config.hooks.create = { expr: remoteField.hooks.create.expr };
+			if (remoteField.hooks.update?.expr) config.hooks.update = { expr: remoteField.hooks.update.expr };
+		}
+		if (remoteField.validate && remoteField.validate.length > 0) config.validate = remoteField.validate.map((v) => ({
+			script: { expr: v.script?.expr ?? "" },
+			errorMessage: v.errorMessage ?? ""
+		}));
+		if (remoteField.serial) config.serial = {
+			start: Number(remoteField.serial.start),
+			...remoteField.serial.maxValue && { maxValue: Number(remoteField.serial.maxValue) },
+			...remoteField.serial.format && { format: remoteField.serial.format }
+		};
 		fields[fieldName] = config;
 	}
 	return fields;
@@ -8321,19 +8690,24 @@ function compareFields(typeName, fieldName, remoteField, snapshotField) {
 	const snapshotFk = snapshotField.foreignKey ?? false;
 	if (remoteFk !== snapshotFk) differences.push(`foreignKey: remote=${remoteFk}, expected=${snapshotFk}`);
 	if (remoteField.foreignKeyType !== snapshotField.foreignKeyType) differences.push(`foreignKeyType: remote=${remoteField.foreignKeyType ?? "none"}, expected=${snapshotField.foreignKeyType ?? "none"}`);
-	const remoteAllowed = new Set(remoteField.allowedValues ?? []);
-	const snapshotAllowed = new Set(snapshotField.allowedValues ?? []);
-	if (remoteAllowed.size !== snapshotAllowed.size) differences.push(`allowedValues count: remote=${remoteAllowed.size}, expected=${snapshotAllowed.size}`);
+	const remoteAllowed = remoteField.allowedValues ?? [];
+	const snapshotAllowed = snapshotField.allowedValues ?? [];
+	const remoteAllowedValues = new Set(remoteAllowed.map((v) => v.value));
+	const snapshotAllowedValues = new Set(snapshotAllowed.map((v) => v.value));
+	if (remoteAllowedValues.size !== snapshotAllowedValues.size) differences.push(`allowedValues count: remote=${remoteAllowedValues.size}, expected=${snapshotAllowedValues.size}`);
 	else {
-		for (const v of remoteAllowed) if (!snapshotAllowed.has(v)) {
+		for (const v of remoteAllowedValues) if (!snapshotAllowedValues.has(v)) {
 			differences.push(`allowedValues: remote has '${v}' not in snapshot`);
 			break;
 		}
-		for (const v of snapshotAllowed) if (!remoteAllowed.has(v)) {
+		for (const v of snapshotAllowedValues) if (!remoteAllowedValues.has(v)) {
 			differences.push(`allowedValues: snapshot has '${v}' not in remote`);
 			break;
 		}
 	}
+	const remoteVector = remoteField.vector ?? false;
+	const snapshotVector = snapshotField.vector ?? false;
+	if (remoteVector !== snapshotVector) differences.push(`vector: remote=${remoteVector}, expected=${snapshotVector}`);
 	if (differences.length > 0) return {
 		typeName,
 		kind: "field_mismatch",
@@ -9044,10 +9418,16 @@ function applyPreMigrationFieldAdjustments(fields, typeChanges) {
 		if (!before?.required && after?.required) field.required = false;
 		if (!(before?.unique ?? false) && (after?.unique ?? false)) field.unique = false;
 		if (before?.allowedValues && after?.allowedValues) {
-			if (before.allowedValues.filter((value) => !after.allowedValues.includes(value)).length > 0) field.allowedValues = [...new Set([...before.allowedValues, ...after.allowedValues])].map((value) => ({
-				value,
-				description: ""
-			}));
+			const afterValues = new Set(after.allowedValues.map((v) => v.value));
+			if (before.allowedValues.filter((v) => !afterValues.has(v.value)).length > 0) {
+				const valueMap = /* @__PURE__ */ new Map();
+				for (const v of before.allowedValues) valueMap.set(v.value, v.description ?? "");
+				for (const v of after.allowedValues) if (!valueMap.has(v.value)) valueMap.set(v.value, v.description ?? "");
+				field.allowedValues = Array.from(valueMap.entries()).map(([value, description]) => ({
+					value,
+					description
+				}));
+			}
 		}
 	}
 }
@@ -11517,31 +11897,31 @@ const jobsCommand = defineCommand({
 	description: "List or get executor jobs.",
 	examples: [
 		{
-			cmd: "tailor-sdk executor jobs my-executor",
+			cmd: "my-executor",
 			desc: "List jobs for an executor (default: 50 jobs)"
 		},
 		{
-			cmd: "tailor-sdk executor jobs my-executor --limit 10",
+			cmd: "my-executor --limit 10",
 			desc: "Limit the number of jobs"
 		},
 		{
-			cmd: "tailor-sdk executor jobs my-executor -s RUNNING",
+			cmd: "my-executor -s RUNNING",
 			desc: "Filter by status"
 		},
 		{
-			cmd: "tailor-sdk executor jobs my-executor <job-id>",
+			cmd: "my-executor <job-id>",
 			desc: "Get job details"
 		},
 		{
-			cmd: "tailor-sdk executor jobs my-executor <job-id> --attempts",
+			cmd: "my-executor <job-id> --attempts",
 			desc: "Get job details with attempts"
 		},
 		{
-			cmd: "tailor-sdk executor jobs my-executor <job-id> -W",
+			cmd: "my-executor <job-id> -W",
 			desc: "Wait for job to complete"
 		},
 		{
-			cmd: "tailor-sdk executor jobs my-executor <job-id> -W -l",
+			cmd: "my-executor <job-id> -W -l",
 			desc: "Wait for job with logs"
 		}
 	],
@@ -11769,23 +12149,23 @@ When using \`--wait\`, the CLI tracks not only the executor job but also any dow
 The \`--logs\` option displays logs from the downstream execution when available.`,
 	examples: [
 		{
-			cmd: "tailor-sdk executor trigger my-executor",
+			cmd: "my-executor",
 			desc: "Trigger an executor"
 		},
 		{
-			cmd: "tailor-sdk executor trigger my-executor -d '{\"message\": \"hello\"}'",
+			cmd: "my-executor -d '{\"message\": \"hello\"}'",
 			desc: "Trigger with data"
 		},
 		{
-			cmd: "tailor-sdk executor trigger my-executor -d '{\"message\": \"hello\"}' -H \"X-Custom: value\" -H \"X-Another: value2\"",
+			cmd: "my-executor -d '{\"message\": \"hello\"}' -H \"X-Custom: value\" -H \"X-Another: value2\"",
 			desc: "Trigger with data and headers"
 		},
 		{
-			cmd: "tailor-sdk executor trigger my-executor -W",
+			cmd: "my-executor -W",
 			desc: "Trigger and wait for completion"
 		},
 		{
-			cmd: "tailor-sdk executor trigger my-executor -W -l",
+			cmd: "my-executor -W -l",
 			desc: "Trigger, wait, and show logs"
 		}
 	],
@@ -13181,13 +13561,15 @@ function extractBreakingChangeFields(diff) {
 			optionalToRequired.get(change.typeName).add(change.fieldName);
 		}
 		if (before && after && before.type === "enum" && after.type === "enum" && before.allowedValues && after.allowedValues) {
-			const beforeSet = new Set(before.allowedValues);
-			const afterSet = new Set(after.allowedValues);
-			if (before.allowedValues.some((v) => !afterSet.has(v)) || after.allowedValues.some((v) => !beforeSet.has(v))) {
+			const beforeValues = before.allowedValues.map((v) => v.value);
+			const afterValues = after.allowedValues.map((v) => v.value);
+			const beforeSet = new Set(beforeValues);
+			const afterSet = new Set(afterValues);
+			if (beforeValues.some((v) => !afterSet.has(v)) || afterValues.some((v) => !beforeSet.has(v))) {
 				if (!enumValueChanges.has(change.typeName)) enumValueChanges.set(change.typeName, /* @__PURE__ */ new Map());
 				enumValueChanges.get(change.typeName).set(change.fieldName, {
-					beforeValues: before.allowedValues,
-					afterValues: after.allowedValues
+					beforeValues,
+					afterValues
 				});
 			}
 		}
@@ -13359,8 +13741,10 @@ function generateFieldType(config, isOptionalToRequired, enumValueChange) {
 	};
 	let baseType;
 	let usedTimestamp = false;
-	if (config.type === "enum") baseType = config.allowedValues && config.allowedValues.length > 0 ? formatEnumUnion(config.allowedValues) : "string";
-	else {
+	if (config.type === "enum") {
+		const enumValues = config.allowedValues?.map((v) => v.value) ?? [];
+		baseType = enumValues.length > 0 ? formatEnumUnion(enumValues) : "string";
+	} else {
 		const mapped = mapToTsType(config.type);
 		baseType = mapped.type;
 		usedTimestamp = mapped.usedTimestamp;
@@ -14871,4 +15255,4 @@ const updateCommand = defineCommand({
 
 //#endregion
 export { jobsCommand as $, initOperatorClient as $t, generateCommand as A, getMigrationFiles as At, getMachineUserToken as B, generateUserTypes as Bt, resumeCommand as C, compareLocalTypesWithSnapshot as Ct, truncate as D, getLatestMigrationNumber as Dt, listWorkflows as E, formatMigrationNumber as Et, removeCommand$1 as F, formatDiffSummary as Ft, generateCommand$1 as G, fetchLatestToken as Gt, listCommand$5 as H, getDistDir as Ht, listCommand$4 as I, formatMigrationDiff as It, triggerCommand as J, readPlatformConfig as Jt, listWebhookExecutors as K, loadAccessToken as Kt, listOAuth2Clients as L, hasChanges as Lt, show as M, isValidMigrationNumber as Mt, showCommand as N, loadDiff as Nt, truncateCommand as O, getMigrationDirPath as Ot, remove as P, reconstructSnapshotFromMigrations as Pt, getExecutorJob as Q, initOAuth2Client as Qt, getCommand$1 as R, getNamespacesWithMigrations as Rt, healthCommand as S, SCHEMA_FILE_NAME as St, listCommand$3 as T, createSnapshotFromLocalTypes as Tt, listMachineUsers as U, apiCall as Ut, tokenCommand as V, loadConfig as Vt, generate$1 as W, apiCommand as Wt, listCommand$6 as X, fetchAll as Xt, triggerExecutor as Y, writePlatformConfig as Yt, listExecutors as Z, fetchUserInfo as Zt, createCommand as _, bundleMigrationScript as _t, listCommand as a, jsonArgs as an, getWorkflow as at, listCommand$2 as b, INITIAL_SCHEMA_NUMBER as bt, inviteUser as c, listWorkflowExecutions as ct, listCommand$1 as d, apply as dt, readPackageJson as en, listExecutorJobs as et, listWorkspaces as f, applyCommand as ft, deleteWorkspace as g, parseMigrationLabelNumber as gt, deleteCommand as h, MIGRATION_LABEL_KEY as ht, removeUser as i, deploymentArgs as in, getCommand$2 as it, logBetaWarning as j, getNextMigrationNumber as jt, generate as k, getMigrationFilePath as kt, restoreCommand as l, getCommand$3 as lt, getWorkspace as m, waitForExecution$1 as mt, updateUser as n, commonArgs as nn, startCommand as nt, listUsers as o, withCommonArgs as on, executionsCommand as ot, getCommand as p, executeScript as pt, webhookCommand as q, loadWorkspaceId as qt, removeCommand as r, confirmationArgs as rn, startWorkflow as rt, inviteCommand as s, workspaceArgs as sn, getWorkflowExecution as st, updateCommand as t, PATScope as tn, watchExecutorJob as tt, restoreWorkspace as u, getExecutor as ut, createWorkspace as v, DB_TYPES_FILE_NAME as vt, resumeWorkflow as w, compareSnapshots as wt, getAppHealth as x, MIGRATE_FILE_NAME as xt, listApps as y, DIFF_FILE_NAME as yt, getOAuth2Client as z, trnPrefix as zt };
-//# sourceMappingURL=update-B_W-UQnS.mjs.map
+//# sourceMappingURL=update-BnKKm4aR.mjs.map