@stndrds/schema 1.0.0-alpha.188 → 1.0.0-alpha.190

package/dist/chunk-LTHSU4NF.mjs

@@ -0,0 +1,639 @@
+import { createCheckboxValidator } from './chunk-TMYBEXBT.mjs';
+import { createDateValidator } from './chunk-4KRLCWJM.mjs';
+import { createNumberValidator } from './chunk-KNYZH2WD.mjs';
+import { createRatingValidator } from './chunk-RUYUFXNW.mjs';
+import { createTextAreaValidator, createTextValidator } from './chunk-KWVCGQ7N.mjs';
+import { createRichtextValidator } from './chunk-BLXQGQLK.mjs';
+import { createMultiselectValidator, createSelectValidator, createStatusValidator } from './chunk-SMOHDR6M.mjs';
+import { createUserValidator } from './chunk-ITTQ4FGR.mjs';
+import { createFormulaValidator } from './chunk-IRTRJH37.mjs';
+import { createRollupValidator } from './chunk-OLJLCVNY.mjs';
+import { createCurrencyValidator } from './chunk-TEQNVO7W.mjs';
+import { createFileValidator } from './chunk-4TC27SMF.mjs';
+import { createLocationValidator } from './chunk-TBYXYSGA.mjs';
+import { createPhoneValidator } from './chunk-Z75P63VF.mjs';
+import { createRelationValidator } from './chunk-R4CJHCC4.mjs';
+import { DEFAULT_VALIDATION_MESSAGES, formatZodErrors } from './chunk-UQVW4KPP.mjs';
+import { z } from 'zod';
+
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (value instanceof Date) return false;
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return Object.values(value).every(
+      (v) => v === null || v === void 0 || typeof v === "string" && v.trim() === ""
+    );
+  }
+  return false;
+}
+function withEmptyToNull(validator) {
+  return z.preprocess((val) => isEmptyValue(val) ? null : val, validator.nullish());
+}
+
+// src/validation/object/attribute-factory.ts
+function createAttributeValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  switch (attr.type) {
+    case "text":
+      return createTextValidator(attr, messages);
+    case "textarea":
+      return createTextAreaValidator(attr, messages);
+    case "richtext":
+      return createRichtextValidator(attr, messages);
+    case "number":
+      return createNumberValidator(attr, messages);
+    case "checkbox":
+      return createCheckboxValidator(attr, messages);
+    case "date":
+      return createDateValidator(attr, messages);
+    case "phone":
+      return createPhoneValidator(attr, messages);
+    case "currency":
+      return createCurrencyValidator(attr, messages);
+    case "status":
+      return createStatusValidator(attr, messages);
+    case "location":
+      return createLocationValidator(attr, messages);
+    case "select":
+      return createSelectValidator(attr, messages);
+    case "multiselect":
+      return createMultiselectValidator(attr, messages);
+    case "file":
+      return createFileValidator(attr, messages);
+    case "user":
+      return createUserValidator(attr, messages);
+    case "relation":
+      return createRelationValidator(attr, messages);
+    case "rating":
+      return createRatingValidator(attr, messages);
+    case "formula":
+      return createFormulaValidator(attr, messages);
+    case "rollup":
+      return createRollupValidator(attr, messages);
+    default:
+      return z.unknown();
+  }
+}
+function createFormAttributeValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const validator = createAttributeValidator(attr, messages);
+  if (!attr.required) {
+    return withEmptyToNull(validator);
+  }
+  return validator;
+}
+var objectValidatorCache = /* @__PURE__ */ new WeakMap();
+var draftValidatorCache = /* @__PURE__ */ new WeakMap();
+function createObjectValidator(objectDef) {
+  const cached = objectValidatorCache.get(objectDef);
+  if (cached) return cached;
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr);
+    shape[attr.name] = attr.required ? validator : withEmptyToNull(validator);
+  }
+  const schema = z.object(shape).passthrough();
+  objectValidatorCache.set(objectDef, schema);
+  return schema;
+}
+function createDraftValidator(objectDef) {
+  const cached = draftValidatorCache.get(objectDef);
+  if (cached) return cached;
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr);
+    shape[attr.name] = withEmptyToNull(validator);
+  }
+  const schema = z.object(shape).passthrough();
+  draftValidatorCache.set(objectDef, schema);
+  return schema;
+}
+
+// src/exceptions.ts
+var SchemaErrorCode = {
+  // Generic
+  UNKNOWN: "SCHEMA_UNKNOWN_ERROR",
+  // Not Found
+  OBJECT_NOT_FOUND: "SCHEMA_OBJECT_NOT_FOUND",
+  ATTRIBUTE_NOT_FOUND: "SCHEMA_ATTRIBUTE_NOT_FOUND",
+  RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND",
+  ROLE_NOT_FOUND: "SCHEMA_ROLE_NOT_FOUND",
+  MEMORY_NOT_FOUND: "SCHEMA_MEMORY_NOT_FOUND",
+  // Validation
+  VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
+  INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME",
+  INVALID_OBJECT_NAME: "SCHEMA_INVALID_OBJECT_NAME",
+  // Protected Resources
+  PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT",
+  PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE",
+  PROTECTED_VIEW: "SCHEMA_PROTECTED_VIEW",
+  PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE",
+  // Permissions
+  FORBIDDEN: "SCHEMA_FORBIDDEN",
+  ACCESS_DENIED: "SCHEMA_ACCESS_DENIED",
+  // Sync
+  SYNC_FAILED: "SCHEMA_SYNC_FAILED",
+  SYNC_CONFLICT: "SCHEMA_SYNC_CONFLICT",
+  SYNC_CASCADE: "SCHEMA_SYNC_CASCADE",
+  ORPHAN_SYSTEM_ATTRIBUTE: "SCHEMA_ORPHAN_SYSTEM_ATTRIBUTE",
+  // System Entity Immutability
+  SYSTEM_ENTITY_IMMUTABLE: "SCHEMA_SYSTEM_ENTITY_IMMUTABLE",
+  // L2 — migration system simplification (2026-05-17)
+  DESTRUCTIVE_NOT_ALLOWED: "SCHEMA_DESTRUCTIVE_NOT_ALLOWED",
+  MIGRATION_TIMEOUT: "SCHEMA_MIGRATION_TIMEOUT",
+  CHANGE_TYPE_NOT_SUPPORTED: "SCHEMA_CHANGE_TYPE_NOT_SUPPORTED",
+  // Duplicates
+  DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT",
+  DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE",
+  // Concurrency
+  CONFLICT: "SCHEMA_CONFLICT",
+  // Storage
+  STORAGE_UPLOAD_FAILED: "SCHEMA_STORAGE_UPLOAD_FAILED",
+  STORAGE_DOWNLOAD_FAILED: "SCHEMA_STORAGE_DOWNLOAD_FAILED",
+  STORAGE_DELETE_FAILED: "SCHEMA_STORAGE_DELETE_FAILED",
+  STORAGE_URL_FAILED: "SCHEMA_STORAGE_URL_FAILED",
+  // Repository Operations
+  REPOSITORY_CREATE_FAILED: "SCHEMA_REPOSITORY_CREATE_FAILED",
+  REPOSITORY_UPDATE_FAILED: "SCHEMA_REPOSITORY_UPDATE_FAILED",
+  REPOSITORY_DELETE_FAILED: "SCHEMA_REPOSITORY_DELETE_FAILED",
+  REPOSITORY_QUERY_FAILED: "SCHEMA_REPOSITORY_QUERY_FAILED",
+  // Not Implemented
+  NOT_IMPLEMENTED: "SCHEMA_NOT_IMPLEMENTED",
+  // Timeout
+  TIMEOUT: "SCHEMA_TIMEOUT",
+  // Schema Integrity
+  RECORD_REFERENCED: "SCHEMA_RECORD_REFERENCED",
+  ATTRIBUTE_IN_USE: "SCHEMA_ATTRIBUTE_IN_USE",
+  OBJECT_REFERENCED: "SCHEMA_OBJECT_REFERENCED"
+};
+var SchemaError = class extends Error {
+  constructor(message, code = SchemaErrorCode.UNKNOWN, details) {
+    super(message);
+    this.name = "SchemaError";
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+var NotFoundError = class extends SchemaError {
+  constructor(resourceType, resourceId, code = SchemaErrorCode.RECORD_NOT_FOUND) {
+    super(`${resourceType} with id "${resourceId}" not found`, code, {
+      resourceType,
+      resourceId
+    });
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var ObjectNotFoundError = class extends NotFoundError {
+  constructor(objectId) {
+    super("Object", objectId, SchemaErrorCode.OBJECT_NOT_FOUND);
+    this.name = "ObjectNotFoundError";
+  }
+};
+var AttributeNotFoundError = class extends NotFoundError {
+  constructor(attributeId) {
+    super("Attribute", attributeId, SchemaErrorCode.ATTRIBUTE_NOT_FOUND);
+    this.name = "AttributeNotFoundError";
+  }
+};
+var RecordNotFoundError = class extends NotFoundError {
+  constructor(recordId) {
+    super("Record", recordId, SchemaErrorCode.RECORD_NOT_FOUND);
+    this.name = "RecordNotFoundError";
+  }
+};
+var ValidationError = class _ValidationError extends SchemaError {
+  constructor(message, errors) {
+    super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+  /**
+   * Create a validation error from Zod-style errors
+   */
+  static fromZodErrors(errors) {
+    const details = errors.map((err) => ({
+      path: err.path.map(String),
+      message: err.message
+    }));
+    const message = `Validation failed: ${details.map((d) => `${d.path.join(".")}: ${d.message}`).join(", ")}`;
+    return new _ValidationError(message, details);
+  }
+};
+var ProtectedResourceError = class extends SchemaError {
+  constructor(resourceType, resourceName, operation) {
+    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
+    super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
+      resourceType,
+      resourceName,
+      operation
+    });
+    this.name = "ProtectedResourceError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+    this.operation = operation;
+  }
+};
+var SyncError = class extends SchemaError {
+  constructor(objectName, message, cause) {
+    super(`Failed to sync object "${objectName}": ${message}`, SchemaErrorCode.SYNC_FAILED, {
+      objectName,
+      cause: cause?.message
+    });
+    this.name = "SyncError";
+    this.objectName = objectName;
+    this.cause = cause;
+  }
+};
+var SystemEntityImmutableError = class extends SchemaError {
+  constructor(entityType, entityName) {
+    super(
+      `Cannot mutate system ${entityType} "${entityName}". System entities are declared in code and immutable at runtime.`,
+      SchemaErrorCode.SYSTEM_ENTITY_IMMUTABLE,
+      { entityType, entityName }
+    );
+    this.name = "SystemEntityImmutableError";
+    this.entityType = entityType;
+    this.entityName = entityName;
+  }
+};
+var SyncConflictError = class extends SchemaError {
+  constructor(params) {
+    const target = params.attributeName ? `"${params.objectName}.${params.attributeName}"` : `"${params.objectName}"`;
+    super(
+      `Cannot promote runtime entity ${target}: ${params.reason}. Resolve via: (1) relax the code constraint, (2) migrate runtime values manually, or (3) rename the code declaration.`,
+      SchemaErrorCode.SYNC_CONFLICT,
+      {
+        objectName: params.objectName,
+        attributeName: params.attributeName,
+        reason: params.reason
+      }
+    );
+    this.name = "SyncConflictError";
+    this.objectName = params.objectName;
+    this.attributeName = params.attributeName;
+    this.reason = params.reason;
+  }
+};
+var SyncCascadeError = class extends SchemaError {
+  constructor(objectName, conflictingAttributes) {
+    super(
+      `Cannot demote object "${objectName}": attributes ${conflictingAttributes.join(", ")} are still declared in code. Remove them from code first, or restore the object.`,
+      SchemaErrorCode.SYNC_CASCADE,
+      { objectName, conflictingAttributes }
+    );
+    this.name = "SyncCascadeError";
+    this.objectName = objectName;
+    this.conflictingAttributes = conflictingAttributes;
+  }
+};
+var OrphanSystemAttributeError = class extends SchemaError {
+  constructor(objectName, attributeName) {
+    super(
+      `Attribute "${objectName}.${attributeName}" is system:true but its object parent is system:false. This is an invariant violation.`,
+      SchemaErrorCode.ORPHAN_SYSTEM_ATTRIBUTE,
+      { objectName, attributeName }
+    );
+    this.name = "OrphanSystemAttributeError";
+    this.objectName = objectName;
+    this.attributeName = attributeName;
+  }
+};
+var DestructiveSyncNotAllowedError = class extends SchemaError {
+  constructor(operations) {
+    const summary = operations.map((op) => {
+      if (op.type === "remove_attribute") {
+        return `- remove_attribute "${op.objectName ?? "?"}.${op.name}"`;
+      }
+      if (op.type === "remove_object") {
+        return "- remove_object";
+      }
+      return `- ${op.type}`;
+    }).join("\n");
+    super(
+      `Destructive schema operations detected (data will be lost):
+${summary}
+
+To allow Standards to apply these automatically, set the environment variable:
+  STANDARDS_ALLOW_DESTRUCTIVE_SYNC=1
+
+Otherwise, revert your code changes or back up the data first.`,
+      SchemaErrorCode.DESTRUCTIVE_NOT_ALLOWED,
+      { operations }
+    );
+    this.name = "DestructiveSyncNotAllowedError";
+    this.operations = operations;
+  }
+};
+var MigrationTimeoutError = class extends SchemaError {
+  constructor(objectName, migrated, total, maxDurationMs) {
+    super(
+      `Migration for "${objectName}" exceeded the maximum duration (${maxDurationMs}ms). Migrated ${migrated}/${total} records before timeout. Increase STANDARDS_MIGRATION_MAX_DURATION_MS or split the migration into smaller batches.`,
+      SchemaErrorCode.MIGRATION_TIMEOUT,
+      { objectName, migrated, total, maxDurationMs }
+    );
+    this.name = "MigrationTimeoutError";
+    this.objectName = objectName;
+    this.migrated = migrated;
+    this.total = total;
+    this.maxDurationMs = maxDurationMs;
+  }
+};
+var ChangeTypeNotSupportedError = class extends SchemaError {
+  constructor(objectName, attributeName) {
+    super(
+      `Cannot change type of attribute "${objectName}.${attributeName}" via runtime API. Declare a migration in your schema code:
+  object("${objectName}").migration(N, (m) =>
+    m.changeType("${attributeName}", from, to, { transform: (v) => ... })
+  )`,
+      SchemaErrorCode.CHANGE_TYPE_NOT_SUPPORTED,
+      { objectName, attributeName }
+    );
+    this.name = "ChangeTypeNotSupportedError";
+    this.objectName = objectName;
+    this.attributeName = attributeName;
+  }
+};
+var DuplicateError = class extends SchemaError {
+  constructor(resourceType, resourceName) {
+    const code = resourceType === "object" ? SchemaErrorCode.DUPLICATE_OBJECT : SchemaErrorCode.DUPLICATE_ATTRIBUTE;
+    super(
+      `${resourceType === "object" ? "Object" : "Attribute"} "${resourceName}" already exists`,
+      code,
+      { resourceType, resourceName }
+    );
+    this.name = "DuplicateError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+  }
+};
+function isSchemaError(error) {
+  return error instanceof SchemaError;
+}
+function isNotFoundError(error) {
+  return error instanceof NotFoundError;
+}
+function isValidationError(error) {
+  return error instanceof ValidationError;
+}
+function isProtectedResourceError(error) {
+  return error instanceof ProtectedResourceError;
+}
+var ForbiddenError = class extends SchemaError {
+  constructor(objectName, action, userId) {
+    super(`No ${action} permission on object "${objectName}"`, SchemaErrorCode.FORBIDDEN, {
+      objectName,
+      action,
+      userId
+    });
+    this.name = "ForbiddenError";
+    this.objectName = objectName;
+    this.action = action;
+    this.userId = userId;
+  }
+};
+var ProtectedRoleError = class extends SchemaError {
+  constructor(roleName, operation) {
+    super(`Cannot ${operation} system role "${roleName}"`, SchemaErrorCode.PROTECTED_ROLE, {
+      roleName,
+      operation
+    });
+    this.name = "ProtectedRoleError";
+    this.roleName = roleName;
+    this.operation = operation;
+  }
+};
+var RoleNotFoundError = class extends NotFoundError {
+  constructor(roleId) {
+    super("Role", roleId, SchemaErrorCode.ROLE_NOT_FOUND);
+    this.name = "RoleNotFoundError";
+  }
+};
+var ConcurrentModificationError = class extends SchemaError {
+  constructor(recordId) {
+    super(
+      `Record ${recordId} was modified by another request. Please refresh and try again.`,
+      SchemaErrorCode.CONFLICT,
+      { recordId }
+    );
+  }
+};
+var StorageError = class extends SchemaError {
+  constructor(operation, message, path, cause) {
+    const code = operation === "upload" ? SchemaErrorCode.STORAGE_UPLOAD_FAILED : operation === "download" ? SchemaErrorCode.STORAGE_DOWNLOAD_FAILED : operation === "delete" ? SchemaErrorCode.STORAGE_DELETE_FAILED : SchemaErrorCode.STORAGE_URL_FAILED;
+    super(`Storage ${operation} failed: ${message}`, code, {
+      operation,
+      path,
+      cause
+    });
+    this.name = "StorageError";
+    this.operation = operation;
+    this.path = path;
+    this.cause = cause;
+  }
+};
+var AccessDeniedError = class extends SchemaError {
+  constructor(resource, reason) {
+    super(reason ?? `Access denied to resource: ${resource}`, SchemaErrorCode.ACCESS_DENIED, {
+      resource,
+      reason
+    });
+    this.name = "AccessDeniedError";
+    this.resource = resource;
+    this.reason = reason;
+  }
+};
+var RepositoryError = class extends SchemaError {
+  constructor(operation, entity, message, cause) {
+    const code = operation === "create" ? SchemaErrorCode.REPOSITORY_CREATE_FAILED : operation === "update" ? SchemaErrorCode.REPOSITORY_UPDATE_FAILED : operation === "delete" ? SchemaErrorCode.REPOSITORY_DELETE_FAILED : SchemaErrorCode.REPOSITORY_QUERY_FAILED;
+    super(`Failed to ${operation} ${entity}: ${message}`, code, {
+      operation,
+      entity,
+      cause
+    });
+    this.name = "RepositoryError";
+    this.operation = operation;
+    this.entity = entity;
+    this.cause = cause;
+  }
+};
+var NotImplementedError = class extends SchemaError {
+  constructor(feature, milestone) {
+    const message = milestone ? `${feature}: not implemented (${milestone})` : `${feature}: not implemented`;
+    super(message, SchemaErrorCode.NOT_IMPLEMENTED, {
+      feature,
+      milestone
+    });
+    this.name = "NotImplementedError";
+    this.feature = feature;
+    this.milestone = milestone;
+  }
+};
+var MemoryNotFoundError = class extends NotFoundError {
+  constructor(memoryId) {
+    super("Memory", memoryId, SchemaErrorCode.MEMORY_NOT_FOUND);
+    this.name = "MemoryNotFoundError";
+  }
+};
+var RecordReferencedError = class extends SchemaError {
+  constructor(recordId, references) {
+    const total = references.reduce((sum, r) => sum + r.count, 0);
+    super(
+      `Cannot delete record: referenced by ${total} record${total > 1 ? "s" : ""}`,
+      SchemaErrorCode.RECORD_REFERENCED,
+      { recordId, references }
+    );
+    this.name = "RecordReferencedError";
+    this.recordId = recordId;
+    this.references = references;
+  }
+};
+var AttributeInUseError = class extends SchemaError {
+  constructor(attributeName, usage) {
+    super(
+      `Cannot delete attribute "${attributeName}": used in ${usage}`,
+      SchemaErrorCode.ATTRIBUTE_IN_USE,
+      { attributeName, usage }
+    );
+    this.name = "AttributeInUseError";
+    this.attributeName = attributeName;
+    this.usage = usage;
+  }
+};
+var ObjectReferencedError = class extends SchemaError {
+  constructor(objectName, referencingObjects) {
+    super(
+      `Cannot delete object "${objectName}": target of relations in ${referencingObjects.join(", ")}`,
+      SchemaErrorCode.OBJECT_REFERENCED,
+      { objectName, referencingObjects }
+    );
+    this.name = "ObjectReferencedError";
+    this.objectName = objectName;
+    this.referencingObjects = referencingObjects;
+  }
+};
+function isRecordReferencedError(error) {
+  return error instanceof RecordReferencedError;
+}
+function isAttributeInUseError(error) {
+  return error instanceof AttributeInUseError;
+}
+function isObjectReferencedError(error) {
+  return error instanceof ObjectReferencedError;
+}
+
+// src/validation/object/helpers.ts
+function validateAttribute(attr, value) {
+  const validator = createAttributeValidator(attr);
+  if (!attr.required && (value === void 0 || value === null)) {
+    return { success: true, data: { [attr.name]: value } };
+  }
+  const result = validator.safeParse(value);
+  if (result.success) {
+    return {
+      success: true,
+      data: { [attr.name]: result.data }
+    };
+  }
+  return {
+    success: false,
+    errors: formatZodErrors(result.error).map((err) => ({
+      path: [attr.name, ...err.path],
+      message: err.message
+    }))
+  };
+}
+function validateObject(objectDef, data) {
+  const validator = createObjectValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: formatZodErrors(result.error)
+  };
+}
+function validateObjectOrThrow(objectDef, data) {
+  const result = validateObject(objectDef, data);
+  if (!result.success) {
+    const errors = result.errors ?? [];
+    const detail = errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new ValidationError(
+      `Validation failed for ${objectDef.label}:
+${detail}`,
+      errors.map((err) => ({ path: err.path, message: err.message }))
+    );
+  }
+  return result.data;
+}
+function validateDraft(objectDef, data) {
+  const validator = createDraftValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: formatZodErrors(result.error)
+  };
+}
+function validateDraftOrThrow(objectDef, data) {
+  const result = validateDraft(objectDef, data);
+  if (!result.success) {
+    const errors = result.errors ?? [];
+    const detail = errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new ValidationError(
+      `Draft validation failed for ${objectDef.label}:
+${detail}`,
+      errors.map((err) => ({ path: err.path, message: err.message }))
+    );
+  }
+  return result.data;
+}
+function isValuePresent(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return false;
+  }
+  return true;
+}
+function getMissingRequiredAttributes(objectDef, data) {
+  const missing = [];
+  for (const attr of objectDef.attributes) {
+    if (attr.required && !isValuePresent(data[attr.name])) {
+      missing.push(attr);
+    }
+  }
+  return missing;
+}
+function isRecordComplete(objectDef, data) {
+  const missing = getMissingRequiredAttributes(objectDef, data);
+  if (missing.length > 0) {
+    return false;
+  }
+  const validation = validateObject(objectDef, data);
+  return validation.success;
+}
+function computeRecordStatus(objectDef, data) {
+  return isRecordComplete(objectDef, data) ? "complete" : "draft";
+}
+
+export { AccessDeniedError, AttributeInUseError, AttributeNotFoundError, ChangeTypeNotSupportedError, ConcurrentModificationError, DestructiveSyncNotAllowedError, DuplicateError, ForbiddenError, MemoryNotFoundError, MigrationTimeoutError, NotFoundError, NotImplementedError, ObjectNotFoundError, ObjectReferencedError, OrphanSystemAttributeError, ProtectedResourceError, ProtectedRoleError, RecordNotFoundError, RecordReferencedError, RepositoryError, RoleNotFoundError, SchemaError, SchemaErrorCode, StorageError, SyncCascadeError, SyncConflictError, SyncError, SystemEntityImmutableError, ValidationError, computeRecordStatus, createAttributeValidator, createDraftValidator, createFormAttributeValidator, createObjectValidator, getMissingRequiredAttributes, isAttributeInUseError, isNotFoundError, isObjectReferencedError, isProtectedResourceError, isRecordComplete, isRecordReferencedError, isSchemaError, isValidationError, validateAttribute, validateDraft, validateDraftOrThrow, validateObject, validateObjectOrThrow };

package/dist/{helpers-BjuFhbQQ.d.mts → helpers-HrKmSkLi.d.mts}

@@ -32,7 +32,10 @@ declare function validateAttribute(attr: Attribute, value: unknown): ValidationR
  */
 declare function validateObject(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
 /**
- * Validate and throw if invalid
+ * Validate and throw if invalid.
+ *
+ * Throws `ValidationError` (code `SCHEMA_VALIDATION_FAILED`) on failure so HTTP
+ * adapters can map it to 400. Generic `Error` would bubble up to a 500.
  */
 declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
 /**
@@ -43,6 +46,9 @@ declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record
 declare function validateDraft(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
 /**
  * Validate draft data and throw if format validation fails.
+ *
+ * Same contract as `validateObjectOrThrow` but skips `required()` checks.
+ * Throws `ValidationError` so HTTP adapters map it to 400.
  */
 declare function validateDraftOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
 /**

package/dist/{helpers-CSuoa3kj.d.ts → helpers-Y9rNQ6sz.d.ts}

@@ -32,7 +32,10 @@ declare function validateAttribute(attr: Attribute, value: unknown): ValidationR
  */
 declare function validateObject(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
 /**
- * Validate and throw if invalid
+ * Validate and throw if invalid.
+ *
+ * Throws `ValidationError` (code `SCHEMA_VALIDATION_FAILED`) on failure so HTTP
+ * adapters can map it to 400. Generic `Error` would bubble up to a 500.
  */
 declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
 /**
@@ -43,6 +46,9 @@ declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record
 declare function validateDraft(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
 /**
  * Validate draft data and throw if format validation fails.
+ *
+ * Same contract as `validateObjectOrThrow` but skips `required()` checks.
+ * Throws `ValidationError` so HTTP adapters map it to 400.
  */
 declare function validateDraftOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
 /**

package/dist/index.d.mts

@@ -9,7 +9,7 @@ import z from 'zod';
 export { V as ValidationMessages } from './types-C5DittlR.mjs';
 export { DEFAULT_VALIDATION_MESSAGES, formatZodErrors } from './validation/core/index.mjs';
 export { parseAttributeConfig } from './validation/config/index.mjs';
-export { c as computeRecordStatus, a as createFormAttributeValidator, v as validateDraft, b as validateDraftOrThrow, d as validateObject, e as validateObjectOrThrow } from './helpers-BjuFhbQQ.mjs';
+export { c as computeRecordStatus, a as createFormAttributeValidator, v as validateDraft, b as validateDraftOrThrow, d as validateObject, e as validateObjectOrThrow } from './helpers-HrKmSkLi.mjs';
 
 /**
  * Generic list options for pagination and sorting