@stndrds/schema 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/runtime.js

@@ -59,21 +59,25 @@ var init_default_roles = __esm({
       /** Tenant settings and configuration */
       SETTINGS: "settings",
       /** Audit logs and activity trail */
-      AUDIT: "audit"
+      AUDIT: "audit",
+      /** File uploads and storage management */
+      FILES: "files"
     };
     ALL_SYSTEM_RESOURCES = [
       SYSTEM_RESOURCES.USERS,
       SYSTEM_RESOURCES.SCHEMA,
       SYSTEM_RESOURCES.ROLES,
       SYSTEM_RESOURCES.SETTINGS,
-      SYSTEM_RESOURCES.AUDIT
+      SYSTEM_RESOURCES.AUDIT,
+      SYSTEM_RESOURCES.FILES
     ];
     SYSTEM_RESOURCE_LABELS = {
       users: "Users",
       schema: "Schema",
       roles: "Roles & Permissions",
       settings: "Settings",
-      audit: "Audit Logs"
+      audit: "Audit Logs",
+      files: "Files"
     };
     DEFAULT_ROLES = {
       /** Full platform access - can manage everything */
@@ -131,9 +135,11 @@ __export(runtime_exports, {
   RecordService: () => RecordService,
   RelationService: () => RelationService,
   UserProfileService: () => UserProfileService,
+  UserService: () => UserService,
   ViewService: () => ViewService,
   buildAuditChanges: () => buildAuditChanges,
   createMockAdapter: () => createMockAdapter,
+  enrichValuesWithSelectLabels: () => enrichValuesWithSelectLabels,
   extractAttributeNames: () => extractAttributeNames,
   getSyncPreview: () => getSyncPreview,
   getViewSyncPreview: () => getViewSyncPreview,
@@ -165,6 +171,175 @@ function generateId() {
   });
 }
 
+// src/format.ts
+var import_constants = require("@stndrds/constants");
+var EMPTY_VALUE_PLACEHOLDER = "\u2014";
+function formatText(value) {
+  return String(value);
+}
+function formatCheckbox(value) {
+  return value ? "Yes" : "No";
+}
+function formatNumber(value, attribute) {
+  if (typeof value !== "number") return String(value);
+  const decimals = attribute.decimals;
+  if (attribute.unit === "percentage") {
+    return value.toLocaleString(void 0, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    });
+  }
+  return value.toLocaleString(void 0, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function formatCurrency(value, _attribute) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const currency = value;
+  if (!("value" in currency && "code" in currency)) return String(value);
+  const formattedValue = currency.value.toLocaleString(void 0, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+  return `${formattedValue} ${currency.code}`;
+}
+function formatDate(value) {
+  if (value instanceof Date) {
+    return value.toISOString().split("T")[0];
+  }
+  if (typeof value === "string") {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date.toISOString().split("T")[0];
+    }
+  }
+  return String(value);
+}
+function formatTimestamp(value) {
+  if (typeof value === "number") {
+    return new Date(value).toISOString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return String(value);
+}
+function formatPhone(value) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const phone = value;
+  if (!("phoneNumber" in phone)) return String(value);
+  if (phone.countryCode) {
+    const country = (0, import_constants.getCountryByIso3)(phone.countryCode);
+    const dial = country?.phoneCode ?? "";
+    return `${dial} ${phone.phoneNumber}`.trim();
+  }
+  return phone.phoneNumber;
+}
+function formatLocation(value, attribute) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const loc = value;
+  const granularity = attribute.granularity ?? "full";
+  const parts = [];
+  switch (granularity) {
+    case "country":
+      if (loc.country) parts.push(loc.country);
+      break;
+    case "state":
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(loc.country);
+      break;
+    case "city":
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(loc.country);
+      break;
+    case "coordinates":
+      if (loc.latitude !== void 0 && loc.longitude !== void 0) {
+        parts.push(`${loc.latitude}, ${loc.longitude}`);
+      }
+      break;
+    case "address":
+      if (loc.address) parts.push(loc.address);
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(loc.country);
+      break;
+    default:
+      if (loc.address) parts.push(loc.address);
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.postalCode) parts.push(loc.postalCode);
+      if (loc.country) parts.push(loc.country);
+      break;
+  }
+  return parts.join(", ") || EMPTY_VALUE_PLACEHOLDER;
+}
+function formatSelect(value, attribute) {
+  if (typeof value !== "string") return String(value);
+  const option = attribute.options?.find((o) => o.value === value);
+  return option?.label ?? String(value);
+}
+function formatMultiselect(value, attribute) {
+  if (!Array.isArray(value)) return String(value);
+  if (attribute.options) {
+    const labels = value.map((v) => attribute.options.find((o) => o.value === v)?.label).filter(Boolean);
+    return labels.join(", ");
+  }
+  return value.join(", ");
+}
+function formatRating(value, attribute) {
+  if (typeof value !== "number") return String(value);
+  const max = attribute.max ?? 5;
+  return `${value}/${max}`;
+}
+function formatAttributeValue(value, attribute) {
+  if (value === null || value === void 0 || value === "") {
+    return EMPTY_VALUE_PLACEHOLDER;
+  }
+  switch (attribute.type) {
+    case "text":
+    case "textarea":
+      return formatText(value);
+    case "checkbox":
+      return formatCheckbox(value);
+    case "number":
+      return formatNumber(value, attribute);
+    case "currency":
+      return formatCurrency(value, attribute);
+    case "date":
+      return formatDate(value);
+    case "timestamp":
+      return formatTimestamp(value);
+    case "phone":
+      return formatPhone(value);
+    case "location":
+      return formatLocation(value, attribute);
+    case "select":
+    case "status":
+      return formatSelect(value, attribute);
+    case "multiselect":
+      return formatMultiselect(value, attribute);
+    case "rating":
+      return formatRating(value, attribute);
+    // Unsupported types - return value as-is or placeholder
+    case "file":
+    case "user":
+    case "relation":
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return String(value);
+    default: {
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return String(value);
+    }
+  }
+}
+
 // src/runtime/template.ts
 var pipes = {
   /** Convert to uppercase */
@@ -216,6 +391,24 @@ function extractAttributeNames(template) {
   }
   return names;
 }
+function hasOptions(attr) {
+  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
+}
+function enrichValuesWithSelectLabels(values, attributes) {
+  const enriched = { ...values };
+  for (const attr of attributes) {
+    const value = values[attr.name];
+    if (value == null) continue;
+    const isSelectLike = attr.type === "select" || attr.type === "status" || attr.type === "multiselect";
+    if (!(isSelectLike && hasOptions(attr))) continue;
+    if (attr.type === "multiselect" && Array.isArray(value) && value.length === 0) continue;
+    const formatted = formatAttributeValue(value, attr);
+    if (formatted && formatted !== EMPTY_VALUE_PLACEHOLDER) {
+      enriched[attr.name] = formatted;
+    }
+  }
+  return enriched;
+}
 
 // src/runtime/mock-adapter.ts
 function createMockObjectsRepository(stores) {
@@ -692,14 +885,31 @@ function createMockObjectRecordsRepository(stores) {
           (options.offset ?? 0) + options.limit
         );
       }
+      const attributesByObjectId = /* @__PURE__ */ new Map();
+      for (const attr of stores.attributes.values()) {
+        if (!attributesByObjectId.has(attr.objectId)) {
+          attributesByObjectId.set(attr.objectId, []);
+        }
+        attributesByObjectId.get(attr.objectId)?.push(attr);
+      }
       const results = matchingRecords.map((r) => {
         const obj = objectsMap.get(r.objectId);
         const labelExpression = obj?.labelExpression ?? "{{ name }}";
+        const dbAttrs = attributesByObjectId.get(r.objectId) ?? [];
+        const attrs = dbAttrs.map((a) => ({
+          ...a.config,
+          id: a.id,
+          name: a.name,
+          type: a.type,
+          label: a.config.label ?? a.name,
+          required: a.config.required ?? false
+        }));
+        const enrichedValues = enrichValuesWithSelectLabels(r.values, attrs);
         return {
           objectId: r.objectId,
           objectName: obj?.name ?? "unknown",
           objectLabel: obj?.label ?? "Unknown",
-          label: renderLabelExpression(labelExpression, r.values),
+          label: renderLabelExpression(labelExpression, enrichedValues),
           recordId: r.id,
           values: r.values,
           completionStatus: r.completionStatus,
@@ -1116,6 +1326,10 @@ var AuditService = class {
     this.options = options;
     this.buffer = [];
     this.flushTimer = null;
+    /** Prevents concurrent flush operations */
+    this.isFlushing = false;
+    /** Pending flush promise to allow waiting on concurrent flush */
+    this.flushPromise = null;
     if (options?.async && options.flushIntervalMs) {
       this.startFlushTimer();
     }
@@ -1202,6 +1416,24 @@ var AuditService = class {
     };
     await this.log(entry);
   }
+  /**
+   * Log a file action (upload, update, delete)
+   */
+  async logFileAction(params) {
+    const entry = {
+      tenantId: this.tenantId,
+      actorId: params.actorId,
+      actorEmail: params.actorEmail,
+      actorType: "user",
+      action: params.action,
+      resourceType: "file",
+      resourceId: params.fileId,
+      resourceLabel: params.fileName,
+      changes: params.changes ? this.redactSensitiveFields(params.changes) : void 0,
+      metadata: params.metadata
+    };
+    await this.log(entry);
+  }
   /**
    * Log a system action (no actor)
    */
@@ -1268,14 +1500,23 @@ var AuditService = class {
   // ============================================================================
   /**
    * Flush buffered logs to the database
+   * Protected against concurrent flush calls
    */
   async flush() {
+    if (this.isFlushing && this.flushPromise) {
+      return this.flushPromise;
+    }
     if (this.buffer.length === 0 || !this.adapter.audit) {
       return;
     }
+    this.isFlushing = true;
     const entries = [...this.buffer];
     this.buffer = [];
-    await this.adapter.audit.createMany(entries);
+    this.flushPromise = this.adapter.audit.createMany(entries).finally(() => {
+      this.isFlushing = false;
+      this.flushPromise = null;
+    });
+    return this.flushPromise;
   }
   /**
    * Clean up resources (stop timer, flush remaining logs)
@@ -1297,6 +1538,12 @@ var AuditService = class {
     if (!this.adapter.audit) {
       return;
     }
+    if (entry.actorId && !entry.actorEmail && entry.actorType === "user") {
+      const profile = await this.adapter.userProfiles.findById(entry.actorId);
+      if (profile) {
+        entry.actorEmail = profile.email;
+      }
+    }
     if (this.options?.async) {
       this.buffer.push(entry);
       const batchSize = this.options.batchSize ?? 10;
@@ -1336,21 +1583,105 @@ var AuditService = class {
 
 // src/runtime/services/file.service.ts
 var FileService = class {
-  constructor(adapter, tenantId) {
+  constructor(adapter, tenantId, options) {
     this.adapter = adapter;
     this.tenantId = tenantId;
+    this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
+    this.userId = options?.userId;
+    this.userEmail = options?.userEmail;
   }
+  // ============================================================================
+  // UPLOAD (requires StorageAdapter)
+  // ============================================================================
   /**
-   * Create a new file record (after upload to storage)
+   * Upload a file to storage and create metadata record.
    *
-   * @param data - File metadata
+   * This method orchestrates:
+   * 1. Upload to storage (via StorageAdapter)
+   * 2. Create file metadata in database
+   * 3. Audit log the operation
+   *
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param input - File content and metadata
    * @returns Created file record
+   * @throws Error if StorageAdapter is not configured
    *
    * @example
    * ```typescript
-   * const service = new FileService(adapter, "tenant-123");
+   * const file = await service.uploadFile({
+   *   content: fileBuffer,
+   *   fileName: "document.pdf",
+   *   mimeType: "application/pdf",
+   *   size: 12345,
+   *   uploadedBy: "user-123",
+   *   visibility: "private",
+   *   folderPath: "/documents",
+   *   tags: ["contract", "2025"],
+   * });
+   * ```
+   */
+  async uploadFile(input) {
+    if (!this.adapter.storage) {
+      throw new Error(
+        "StorageAdapter is not configured. Provide adapter.storage to use uploadFile()."
+      );
+    }
+    const uploadResult = await this.adapter.storage.upload({
+      content: input.content,
+      fileName: input.fileName,
+      mimeType: input.mimeType,
+      size: input.size,
+      tenantId: this.tenantId,
+      folderPath: input.folderPath
+    });
+    const file = await this.adapter.files.create({
+      tenantId: this.tenantId,
+      name: input.fileName,
+      originalName: input.fileName,
+      mimeType: input.mimeType,
+      size: input.size,
+      storageProvider: uploadResult.storageProvider,
+      storagePath: uploadResult.storagePath,
+      storageBucket: uploadResult.storageBucket,
+      url: uploadResult.url,
+      uploadedBy: input.uploadedBy,
+      folderPath: input.folderPath,
+      tags: input.tags,
+      visibility: input.visibility ?? "private",
+      allowedUsers: input.allowedUsers
+    });
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.uploaded",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId: file.id,
+        fileName: file.name,
+        metadata: {
+          mimeType: file.mimeType,
+          size: file.size,
+          visibility: file.visibility
+        }
+      });
+    }
+    return file;
+  }
+  // ============================================================================
+  // CREATE (metadata only, for external storage)
+  // ============================================================================
+  /**
+   * Create a new file record (after upload to storage).
+   *
+   * Use this method when handling storage externally (e.g., with Multer + S3).
+   * For integrated upload, use `uploadFile()` instead.
+   *
+   * @param data - File metadata
+   * @returns Created file record
    *
-   * // After uploading to S3
+   * @example
+   * ```typescript
+   * // After uploading to S3 with Multer
    * const file = await service.createFile({
    *   tenantId: "tenant-123",
    *   name: "contract-2025.pdf",
@@ -1372,8 +1703,26 @@ var FileService = class {
         `Tenant mismatch: service initialized with "${this.tenantId}" but data has "${data.tenantId}"`
       );
     }
-    return await this.adapter.files.create(data);
+    const file = await this.adapter.files.create(data);
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.uploaded",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId: file.id,
+        fileName: file.name,
+        metadata: {
+          mimeType: file.mimeType,
+          size: file.size,
+          visibility: file.visibility
+        }
+      });
+    }
+    return file;
   }
+  // ============================================================================
+  // READ
+  // ============================================================================
   /**
    * Get file by ID
    */
@@ -1394,6 +1743,9 @@ var FileService = class {
     }
     return file;
   }
+  // ============================================================================
+  // UPDATE
+  // ============================================================================
   /**
    * Update file metadata
    *
@@ -1402,18 +1754,44 @@ var FileService = class {
    * @returns Updated file
    */
   async updateFile(fileId, data) {
-    await this.getFileOrThrow(fileId);
-    return await this.adapter.files.update(fileId, data);
+    const existingFile = await this.getFileOrThrow(fileId);
+    const updatedFile = await this.adapter.files.update(fileId, data);
+    if (this.auditService && this.userId) {
+      const changes = [];
+      for (const key of Object.keys(data)) {
+        if (data[key] !== void 0 && data[key] !== existingFile[key]) {
+          changes.push({
+            field: key,
+            oldValue: existingFile[key],
+            newValue: data[key]
+          });
+        }
+      }
+      if (changes.length > 0) {
+        await this.auditService.logFileAction({
+          action: "file.updated",
+          actorId: this.userId,
+          actorEmail: this.userEmail,
+          fileId,
+          fileName: updatedFile.name,
+          changes
+        });
+      }
+    }
+    return updatedFile;
   }
+  // ============================================================================
+  // DELETE
+  // ============================================================================
   /**
-   * Delete file (soft delete)
+   * Delete file (soft delete by default)
    *
    * @param fileId - File UUID
    * @param options - Delete options
    */
   async deleteFile(fileId, options) {
+    const file = await this.getFileOrThrow(fileId);
     if (options?.checkOwnership && options.userId) {
-      const file = await this.getFileOrThrow(fileId);
       if (file.uploadedBy !== options.userId) {
         throw new Error("You can only delete files you uploaded");
       }
@@ -1423,7 +1801,84 @@ var FileService = class {
     } else {
       await this.adapter.files.delete(fileId);
     }
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.deleted",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId,
+        fileName: file.name
+      });
+    }
+  }
+  /**
+   * Delete file from both storage and database.
+   *
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param fileId - File UUID
+   * @param options - Delete options
+   * @throws Error if StorageAdapter is not configured
+   */
+  async deleteFileWithStorage(fileId, options) {
+    if (!this.adapter.storage) {
+      throw new Error(
+        "StorageAdapter is not configured. Provide adapter.storage to use deleteFileWithStorage()."
+      );
+    }
+    const file = await this.getFileOrThrow(fileId);
+    await this.adapter.storage.delete(file.storagePath);
+    if (options?.hard) {
+      await this.adapter.files.hardDelete(fileId);
+    } else {
+      await this.adapter.files.delete(fileId);
+    }
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.deleted",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId,
+        fileName: file.name,
+        metadata: { deletedFromStorage: true }
+      });
+    }
+  }
+  /**
+   * Delete multiple files
+   *
+   * @param fileIds - Array of file UUIDs
+   * @param options - Delete options
+   */
+  async bulkDelete(fileIds, options) {
+    for (const fileId of fileIds) {
+      const file = await this.getFile(fileId);
+      if (!file) {
+        continue;
+      }
+      if (options?.deleteFromStorage && this.adapter.storage) {
+        await this.adapter.storage.delete(file.storagePath);
+      }
+      if (options?.hard) {
+        await this.adapter.files.hardDelete(fileId);
+      } else {
+        await this.adapter.files.delete(fileId);
+      }
+      if (this.auditService && this.userId) {
+        await this.auditService.logFileAction({
+          action: "file.deleted",
+          actorId: this.userId,
+          actorEmail: this.userEmail,
+          fileId,
+          fileName: file.name,
+          metadata: { deletedFromStorage: options?.deleteFromStorage ?? false }
+        });
+      }
+    }
   }
+  // ============================================================================
+  // LIST
+  // ============================================================================
   /**
    * List files for the tenant
    */
@@ -1442,6 +1897,74 @@ var FileService = class {
   async listFilesByUploader(uploadedBy) {
     return await this.adapter.files.findByUploader(uploadedBy);
   }
+  // ============================================================================
+  // SIGNED URL
+  // ============================================================================
+  /**
+   * Get a signed URL for private file access.
+   *
+   * Checks access permissions before generating URL.
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param fileId - File UUID
+   * @param userId - User requesting access
+   * @param options - Signed URL options
+   * @returns Signed URL
+   * @throws Error if user doesn't have access or StorageAdapter is not configured
+   *
+   * @example
+   * ```typescript
+   * const url = await service.getSignedUrl("file-123", "user-456", {
+   *   expiresIn: 3600, // 1 hour
+   * });
+   * ```
+   */
+  async getSignedUrl(fileId, userId, options) {
+    const file = await this.getFileOrThrow(fileId);
+    const hasAccess = await this.checkAccess(fileId, userId);
+    if (!hasAccess) {
+      throw new Error("Access denied to this file");
+    }
+    if (file.visibility === "public") {
+      return file.url;
+    }
+    if (!this.adapter.storage) {
+      return file.url;
+    }
+    return await this.adapter.storage.getSignedUrl(file.storagePath, options);
+  }
+  // ============================================================================
+  // ACCESS CONTROL
+  // ============================================================================
+  /**
+   * Check if user has access to a file
+   *
+   * @param fileId - File UUID
+   * @param userId - User ID to check
+   * @returns true if user can access the file
+   */
+  async checkAccess(fileId, userId) {
+    const file = await this.getFile(fileId);
+    if (!file) {
+      return false;
+    }
+    if (file.visibility === "public") {
+      return true;
+    }
+    if (file.uploadedBy === userId) {
+      return true;
+    }
+    if (file.visibility === "restricted") {
+      return file.allowedUsers?.includes(userId) ?? false;
+    }
+    return false;
+  }
+  /**
+   * @deprecated Use checkAccess() instead
+   */
+  canAccess(fileId, userId) {
+    return this.checkAccess(fileId, userId);
+  }
   /**
    * Change file visibility
    *
@@ -1485,29 +2008,9 @@ var FileService = class {
       allowedUsers: newAllowed
     });
   }
-  /**
-   * Check if user has access to a file
-   *
-   * @param fileId - File UUID
-   * @param userId - User ID to check
-   * @returns true if user can access the file
-   */
-  async canAccess(fileId, userId) {
-    const file = await this.getFile(fileId);
-    if (!file) {
-      return false;
-    }
-    if (file.visibility === "public") {
-      return true;
-    }
-    if (file.uploadedBy === userId) {
-      return true;
-    }
-    if (file.visibility === "restricted") {
-      return file.allowedUsers?.includes(userId) ?? false;
-    }
-    return false;
-  }
+  // ============================================================================
+  // ORGANIZATION
+  // ============================================================================
   /**
    * Move file to different folder
    */
@@ -1534,6 +2037,115 @@ var FileService = class {
   }
 };
 
+// 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",
+  USER_PROFILE_NOT_FOUND: "SCHEMA_USER_PROFILE_NOT_FOUND",
+  FILE_NOT_FOUND: "SCHEMA_FILE_NOT_FOUND",
+  ROLE_NOT_FOUND: "SCHEMA_ROLE_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",
+  // Sync
+  SYNC_FAILED: "SCHEMA_SYNC_FAILED",
+  NOT_SYSTEM_OBJECT: "SCHEMA_NOT_SYSTEM_OBJECT",
+  // Duplicates
+  DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT",
+  DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE"
+};
+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 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 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;
+  }
+};
+
 // src/runtime/services/flow.service.ts
 var FlowService = class {
   constructor(adapter, systemFlows = []) {
@@ -1594,16 +2206,26 @@ var FlowService = class {
    */
   async createFlow(input, tenantId) {
     if (!this.adapter.flows) {
-      throw new Error("Flows feature is not enabled. Database adapter does not support flows.");
+      throw new SchemaError(
+        "Flows feature is not enabled. Database adapter does not support flows.",
+        SchemaErrorCode.UNKNOWN,
+        { feature: "flows" }
+      );
     }
     this.validateFlowName(input.name);
     const existing = await this.adapter.flows.findByName(tenantId, input.name);
     if (existing) {
-      throw new Error(`Flow "${input.name}" already exists`);
+      throw new SchemaError(
+        `Flow "${input.name}" already exists`,
+        SchemaErrorCode.DUPLICATE_OBJECT,
+        { flowName: input.name }
+      );
     }
     if (this.systemFlows.has(input.name)) {
-      throw new Error(
-        `Cannot create flow "${input.name}": a system flow with this name already exists`
+      throw new SchemaError(
+        `Cannot create flow "${input.name}": a system flow with this name already exists`,
+        SchemaErrorCode.DUPLICATE_OBJECT,
+        { flowName: input.name, system: true }
       );
     }
     this.validateFlowStructure(input);
@@ -1628,14 +2250,16 @@ var FlowService = class {
    */
   async updateFlow(flowId, input) {
     if (!this.adapter.flows) {
-      throw new Error("Flows feature is not enabled.");
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
     }
     const dbFlow = await this.adapter.flows.findById(flowId);
     if (!dbFlow) {
-      throw new Error(`Flow with id "${flowId}" not found`);
+      throw new NotFoundError("Flow", flowId);
     }
     if (dbFlow.system) {
-      throw new Error("Cannot modify system flows. System flows are protected.");
+      throw new ProtectedResourceError("object", dbFlow.name, "modify");
     }
     if (input.slots || input.pages || input.relations) {
       this.validateFlowStructure({
@@ -1662,14 +2286,16 @@ var FlowService = class {
    */
   async publishFlow(flowId) {
     if (!this.adapter.flows) {
-      throw new Error("Flows feature is not enabled.");
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
     }
     const dbFlow = await this.adapter.flows.findById(flowId);
     if (!dbFlow) {
-      throw new Error(`Flow with id "${flowId}" not found`);
+      throw new NotFoundError("Flow", flowId);
     }
     if (dbFlow.system) {
-      throw new Error("Cannot publish system flows. They are always published.");
+      throw new ProtectedResourceError("object", dbFlow.name, "modify");
     }
     if (dbFlow.status === "published") {
       return this.convertDBFlowToDefinition(dbFlow);
@@ -1692,14 +2318,16 @@ var FlowService = class {
    */
   async archiveFlow(flowId) {
     if (!this.adapter.flows) {
-      throw new Error("Flows feature is not enabled.");
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
     }
     const dbFlow = await this.adapter.flows.findById(flowId);
     if (!dbFlow) {
-      throw new Error(`Flow with id "${flowId}" not found`);
+      throw new NotFoundError("Flow", flowId);
     }
     if (dbFlow.system) {
-      throw new Error("Cannot archive system flows.");
+      throw new ProtectedResourceError("object", dbFlow.name, "modify");
     }
     const updated = await this.adapter.flows.update(flowId, {
       status: "archived"
@@ -1711,14 +2339,16 @@ var FlowService = class {
    */
   async deleteFlow(flowId) {
     if (!this.adapter.flows) {
-      throw new Error("Flows feature is not enabled.");
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
     }
     const dbFlow = await this.adapter.flows.findById(flowId);
     if (!dbFlow) {
-      throw new Error(`Flow with id "${flowId}" not found`);
+      throw new NotFoundError("Flow", flowId);
     }
     if (dbFlow.system) {
-      throw new Error("Cannot delete system flows. System flows are protected.");
+      throw new ProtectedResourceError("object", dbFlow.name, "delete");
     }
     await this.adapter.flows.delete(flowId);
   }
@@ -1730,16 +2360,23 @@ var FlowService = class {
    */
   validateFlowName(name) {
     if (!name || name.length === 0) {
-      throw new Error("Flow name cannot be empty");
+      throw new ValidationError("Flow name cannot be empty", [
+        { path: ["name"], message: "Flow name cannot be empty" }
+      ]);
     }
     if (name.length > 63) {
-      throw new Error("Flow name is too long (max 63 characters)");
+      throw new ValidationError("Flow name is too long", [
+        { path: ["name"], message: "Flow name is too long (max 63 characters)" }
+      ]);
     }
     const kebabCaseRegex = /^[a-z][a-z0-9-]*$/;
     if (!kebabCaseRegex.test(name)) {
-      throw new Error(
-        "Invalid flow name format. Name must be in kebab-case (e.g., 'couple-creation', 'new-contact')"
-      );
+      throw new ValidationError("Invalid flow name format", [
+        {
+          path: ["name"],
+          message: "Flow name must be in kebab-case (e.g., 'couple-creation', 'new-contact')"
+        }
+      ]);
     }
   }
   /**
@@ -1747,33 +2384,59 @@ var FlowService = class {
    */
   validateFlowStructure(input) {
     if (!input.slots || input.slots.length === 0) {
-      throw new Error("Flow must have at least one slot");
+      throw new ValidationError("Flow must have at least one slot", [
+        { path: ["slots"], message: "Flow must have at least one slot" }
+      ]);
     }
     if (!input.pages || input.pages.length === 0) {
-      throw new Error("Flow must have at least one page");
+      throw new ValidationError("Flow must have at least one page", [
+        { path: ["pages"], message: "Flow must have at least one page" }
+      ]);
     }
     const slotIds = new Set(input.slots.map((s) => s.id));
     if (slotIds.size !== input.slots.length) {
-      throw new Error("Duplicate slot IDs detected");
+      throw new ValidationError("Duplicate slot IDs detected", [
+        { path: ["slots"], message: "Duplicate slot IDs detected" }
+      ]);
     }
     for (const page of input.pages) {
       for (const row of page.rows) {
         for (const field of row.fields) {
           if (!slotIds.has(field.slotId)) {
-            throw new Error(`Field "${field.id}" references unknown slot "${field.slotId}"`);
+            throw new ValidationError("Field references unknown slot", [
+              {
+                path: ["pages", page.id, "rows", row.id, "fields", field.id],
+                message: `Field "${field.id}" references unknown slot "${field.slotId}"`
+              }
+            ]);
           }
         }
       }
     }
     for (const relation of input.relations) {
       if (!slotIds.has(relation.sourceSlotId)) {
-        throw new Error(`Relation references unknown source slot "${relation.sourceSlotId}"`);
+        throw new ValidationError("Relation references unknown source slot", [
+          {
+            path: ["relations", relation.id, "sourceSlotId"],
+            message: `Relation references unknown source slot "${relation.sourceSlotId}"`
+          }
+        ]);
       }
       if (!slotIds.has(relation.targetSlotId)) {
-        throw new Error(`Relation references unknown target slot "${relation.targetSlotId}"`);
+        throw new ValidationError("Relation references unknown target slot", [
+          {
+            path: ["relations", relation.id, "targetSlotId"],
+            message: `Relation references unknown target slot "${relation.targetSlotId}"`
+          }
+        ]);
       }
       if (relation.sourceSlotId === relation.targetSlotId) {
-        throw new Error(`Relation cannot link a slot to itself: "${relation.sourceSlotId}"`);
+        throw new ValidationError("Relation cannot link a slot to itself", [
+          {
+            path: ["relations", relation.id],
+            message: `Relation cannot link a slot to itself: "${relation.sourceSlotId}"`
+          }
+        ]);
       }
     }
   }
@@ -1917,8 +2580,8 @@ var GlobalSearchService = class {
 };
 
 // src/builders/attribute-validators.ts
-var import_constants = require("@stndrds/constants");
-var VALID_ICONS = new Set(import_constants.ICONS);
+var import_constants2 = require("@stndrds/constants");
+var VALID_ICONS = new Set(import_constants2.ICONS);
 
 // src/builders/flow-builder.ts
 var import_zod = require("zod");
@@ -2132,6 +2795,13 @@ var optionSchema = import_zod4.z.object({
   description: import_zod4.z.string().optional(),
   group: import_zod4.z.enum(["idle", "in_progress", "finished"]).optional()
 });
+var optionsArraySchema = import_zod4.z.array(optionSchema).min(1).refine(
+  (options) => {
+    const values = options.map((o) => o.value);
+    return new Set(values).size === values.length;
+  },
+  { message: "Duplicate option values are not allowed" }
+);
 var relationTargetSchema = import_zod4.z.object({
   object: import_zod4.z.string().min(1),
   displayTemplate: import_zod4.z.string().optional(),
@@ -2192,7 +2862,7 @@ var currencyConfigSchema = baseConfigSchema.extend({
   allowedCurrencies: import_zod4.z.array(import_zod4.z.string().length(3)).optional()
 });
 var statusConfigSchema = baseConfigSchema.extend({
-  options: import_zod4.z.array(optionSchema).min(1)
+  options: optionsArraySchema
 });
 var locationConfigSchema = baseConfigSchema.extend({
   granularity: import_zod4.z.enum(["full", "address", "city", "state", "country", "coordinates"]),
@@ -2206,19 +2876,21 @@ var timestampConfigSchema = baseConfigSchema.extend({
   autoUpdate: import_zod4.z.boolean().optional()
 });
 var selectConfigSchema = baseConfigSchema.extend({
-  options: import_zod4.z.array(optionSchema).min(1)
+  options: optionsArraySchema
 });
 var multiselectConfigSchema = baseConfigSchema.extend({
-  options: import_zod4.z.array(optionSchema).min(1)
+  options: optionsArraySchema
 });
 var fileConfigSchema = baseConfigSchema.extend({
   maxFiles: import_zod4.z.number().int().min(1).optional(),
   maxSize: import_zod4.z.number().int().min(1).optional(),
   allowedTypes: import_zod4.z.array(import_zod4.z.string()).optional(),
-  verification: fileVerificationConfigSchema.optional()
+  verification: fileVerificationConfigSchema.optional(),
+  multiple: import_zod4.z.boolean().optional()
 });
 var userConfigSchema = baseConfigSchema.extend({
-  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional()
+  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional(),
+  multiple: import_zod4.z.boolean().optional()
 });
 var relationConfigSchema = baseConfigSchema.extend({
   targets: import_zod4.z.array(relationTargetSchema).min(1),
@@ -2340,20 +3012,39 @@ function createLocationValidator(_attr) {
 function createTimestampValidator(_attr) {
   return import_zod4.z.number().int().positive();
 }
-function createFileValidator(_attr) {
-  return import_zod4.z.string().uuid();
+function createFileValidator(attr) {
+  const uuidSchema = import_zod4.z.uuid({
+    message: `${attr.label} must be a valid file ID`
+  });
+  if (attr.multiple) {
+    let arraySchema = import_zod4.z.array(uuidSchema);
+    if (attr.maxFiles) {
+      arraySchema = arraySchema.max(
+        attr.maxFiles,
+        `${attr.label} cannot have more than ${attr.maxFiles} file${attr.maxFiles > 1 ? "s" : ""}`
+      );
+    }
+    return arraySchema;
+  }
+  return uuidSchema;
 }
-function createUserValidator(_attr) {
-  return import_zod4.z.string().uuid();
+function createUserValidator(attr) {
+  const uuidSchema = import_zod4.z.uuid({
+    message: `${attr.label} must be a valid user ID`
+  });
+  if (attr.multiple) {
+    return import_zod4.z.array(uuidSchema);
+  }
+  return uuidSchema;
 }
 function createSingleRelationValidator(attr) {
-  const uuidSchema = import_zod4.z.string().uuid({
+  const uuidSchema = import_zod4.z.uuid({
     message: `${attr.label} must be a valid record ID`
   });
   return import_zod4.z.union([uuidSchema, import_zod4.z.null()]);
 }
 function createMultiRelationValidator(attr) {
-  const uuidSchema = import_zod4.z.string().uuid({
+  const uuidSchema = import_zod4.z.uuid({
     message: `Each ${attr.label} item must be a valid record ID`
   });
   let arraySchema = import_zod4.z.array(uuidSchema);
@@ -2871,14 +3562,15 @@ var ObjectSchemaService = class {
         });
       }
     }
+    const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
+    const attributes = dbAttributes.map((attr) => this.convertDBAttributeToAttribute(attr));
     if (updates.labelExpression !== void 0 && updates.labelExpression !== oldValues.labelExpression) {
       const newExpression = updates.labelExpression;
-      await this.adapter.objectRecords.batchRefreshLabels(
-        objectId,
-        (values) => renderLabelExpression(newExpression, values)
-      );
+      await this.adapter.objectRecords.batchRefreshLabels(objectId, (values) => {
+        const enrichedValues = enrichValuesWithSelectLabels(values, attributes);
+        return renderLabelExpression(newExpression, enrichedValues);
+      });
     }
-    const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
     return this.convertDBObjectToDefinition(updatedDbObject, dbAttributes);
   }
   /**
@@ -3191,71 +3883,14 @@ var ObjectSchemaService = class {
   }
 };
 
-// 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",
-  USER_PROFILE_NOT_FOUND: "SCHEMA_USER_PROFILE_NOT_FOUND",
-  FILE_NOT_FOUND: "SCHEMA_FILE_NOT_FOUND",
-  ROLE_NOT_FOUND: "SCHEMA_ROLE_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_ROLE: "SCHEMA_PROTECTED_ROLE",
-  // Permissions
-  FORBIDDEN: "SCHEMA_FORBIDDEN",
-  // Sync
-  SYNC_FAILED: "SCHEMA_SYNC_FAILED",
-  NOT_SYSTEM_OBJECT: "SCHEMA_NOT_SYSTEM_OBJECT",
-  // Duplicates
-  DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT",
-  DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE"
-};
-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 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;
-  }
-};
-
 // src/runtime/services/permission.service.ts
 var PermissionService = class {
   constructor(adapter, tenantId, options) {
     this.adapter = adapter;
     this.tenantId = tenantId;
     this.cache = /* @__PURE__ */ new Map();
+    /** Track pending permission fetches to prevent duplicate concurrent requests */
+    this.pendingFetches = /* @__PURE__ */ new Map();
     if (!adapter.permissions) {
       throw new Error(
         "PermissionService requires a DatabaseAdapter with permissions repository. Make sure your adapter implements the permissions property."
@@ -3404,6 +4039,23 @@ var PermissionService = class {
     if (cached && cached.expiresAt > Date.now()) {
       return cached.permissions;
     }
+    const pendingFetch = this.pendingFetches.get(cacheKey);
+    if (pendingFetch) {
+      return pendingFetch;
+    }
+    const fetchPromise = this.fetchAndCachePermissions(userProfileId, cacheKey);
+    this.pendingFetches.set(cacheKey, fetchPromise);
+    try {
+      return await fetchPromise;
+    } finally {
+      this.pendingFetches.delete(cacheKey);
+    }
+  }
+  /**
+   * Fetch permissions from database and cache the result
+   * @internal
+   */
+  async fetchAndCachePermissions(userProfileId, cacheKey) {
     const permissions = await this.permissionsRepo.getEffectivePermissions(
       userProfileId,
       this.tenantId
@@ -3932,8 +4584,11 @@ var RelationService = class {
   async validateRelationsOrThrow(schema, data) {
     const result = await this.validateRelations(schema, data);
     if (!result.valid) {
-      const messages = result.errors.map((e) => `${e.attribute}: ${e.message}`).join("; ");
-      throw new Error(`Relation validation failed: ${messages}`);
+      const errors = result.errors.map((e) => ({
+        path: [e.attribute],
+        message: e.message
+      }));
+      throw new ValidationError("Relation validation failed", errors);
     }
   }
   // ============================================================================
@@ -3981,7 +4636,8 @@ var RelationService = class {
       totalCount += result.total;
       for (const record of result.records) {
         const template = target.displayTemplate || objectSchema.labelExpression;
-        const label = renderLabelExpression(template, record.values);
+        const enrichedValues = enrichValuesWithSelectLabels(record.values, objectSchema.attributes);
+        const label = renderLabelExpression(template, enrichedValues);
         allOptions.push({
           id: record.id,
           objectId: objectSchema.id,
@@ -4045,7 +4701,8 @@ var RelationService = class {
         }
       }
       for (const record of objectRecords) {
-        const label = renderLabelExpression(template, record.values);
+        const enrichedValues = enrichValuesWithSelectLabels(record.values, objectSchema.attributes);
+        const label = renderLabelExpression(template, enrichedValues);
         resolved.push({
           id: record.id,
           objectId: record.objectId,
@@ -4066,10 +4723,131 @@ var RelationService = class {
     if (!attribute || attribute.type !== "relation") {
       return null;
     }
-    return {
+    const merged = {
       ...attribute.config,
       ...attribute
     };
+    if (!("targets" in merged && Array.isArray(merged.targets) && "cardinality" in merged)) {
+      return null;
+    }
+    return merged;
+  }
+};
+
+// src/runtime/services/user.service.ts
+var UserService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Validate all user attributes in the data
+   *
+   * @param schema - Object schema containing attribute definitions
+   * @param data - Record data to validate
+   * @returns Validation result with errors if any
+   *
+   * @example
+   * ```typescript
+   * const result = await userService.validateUsers(schema, {
+   *   assignee: "user-123",
+   *   watchers: ["user-456", "user-789"]
+   * });
+   *
+   * if (!result.valid) {
+   *   console.log(result.errors);
+   *   // [{ attribute: "assignee", message: "User not found", invalidIds: ["user-123"] }]
+   * }
+   * ```
+   */
+  async validateUsers(schema, data) {
+    const errors = [];
+    const userAttrs = schema.attributes.filter(
+      (attr) => attr.type === "user"
+    );
+    for (const attr of userAttrs) {
+      const value = data[attr.name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const attrErrors = await this.validateUserAttribute(attr, value);
+      errors.push(...attrErrors);
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Validate a single user attribute value
+   */
+  async validateUserAttribute(attr, value) {
+    const errors = [];
+    const ids = this.extractIds(attr, value);
+    if (ids.length === 0) {
+      return errors;
+    }
+    const invalidIds = [];
+    const roleErrors = [];
+    for (const id of ids) {
+      const user = await this.adapter.userProfiles.findById(id);
+      if (!user) {
+        invalidIds.push(id);
+        continue;
+      }
+      if (user.tenantId !== this.tenantId) {
+        invalidIds.push(id);
+        continue;
+      }
+      if (attr.allowedRoles && attr.allowedRoles.length > 0) {
+        if (!attr.allowedRoles.includes(user.role)) {
+          roleErrors.push(id);
+        }
+      }
+    }
+    if (invalidIds.length > 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `Invalid or non-existent users for ${attr.label}`,
+        invalidIds
+      });
+    }
+    if (roleErrors.length > 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `Users do not have required role for ${attr.label}. Allowed roles: ${attr.allowedRoles?.join(", ")}`,
+        invalidIds: roleErrors
+      });
+    }
+    return errors;
+  }
+  /**
+   * Extract IDs from user value based on multiple flag
+   */
+  extractIds(attr, value) {
+    if (attr.multiple) {
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.filter((v) => typeof v === "string" && v !== "");
+    }
+    if (typeof value === "string" && value !== "") {
+      return [value];
+    }
+    return [];
+  }
+  /**
+   * Validate users and throw if invalid
+   */
+  async validateUsersOrThrow(schema, data) {
+    const result = await this.validateUsers(schema, data);
+    if (!result.valid) {
+      const errors = result.errors.map((e) => ({
+        path: [e.attribute],
+        message: e.message
+      }));
+      throw new ValidationError("User validation failed", errors);
+    }
   }
 };
 
@@ -4080,9 +4858,10 @@ var RecordService = class {
     this.tenantId = tenantId;
     this.schemaService = new ObjectSchemaService(adapter, registry);
     this.relationService = new RelationService(adapter, registry);
+    this.userService = new UserService(adapter, tenantId);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
     this.permissionService = options?.permissionService;
-    this.auditService = options?.auditService;
+    this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
     this.userId = options?.userId;
     this.userEmail = options?.userEmail;
   }
@@ -4149,21 +4928,23 @@ var RecordService = class {
   /**
    * Compute display label from schema expression
    * Automatically resolves relation attribute values to their labels
+   * and select/multiselect values to their option labels
    * @internal
    */
   async computeLabel(schema, values) {
     const attrNames = extractAttributeNames(schema.labelExpression);
+    let enrichedValues = enrichValuesWithSelectLabels(values, schema.attributes);
     const relationAttrs = schema.attributes.filter(
       (attr) => attr.type === "relation" && attrNames.includes(attr.name)
     );
     if (relationAttrs.length === 0) {
-      return renderLabelExpression(schema.labelExpression, values);
+      return renderLabelExpression(schema.labelExpression, enrichedValues);
     }
     const resolvedMap = await this.resolveRelationLabels(relationAttrs, values);
     if (resolvedMap.size === 0) {
-      return renderLabelExpression(schema.labelExpression, values);
+      return renderLabelExpression(schema.labelExpression, enrichedValues);
     }
-    const enrichedValues = { ...values };
+    enrichedValues = { ...enrichedValues };
     for (const attr of relationAttrs) {
       const val = values[attr.name];
       const ids = this.extractRelationIds(val);
@@ -4218,6 +4999,9 @@ var RecordService = class {
       if (!options?.skipRelationValidation) {
         await this.relationService.validateRelationsOrThrow(schema, data);
       }
+      if (!options?.skipUserValidation) {
+        await this.userService.validateUsersOrThrow(schema, data);
+      }
     }
     const completionStatus = computeRecordStatus(schema, data);
     const label = await this.computeLabel(schema, data);
@@ -4276,7 +5060,7 @@ var RecordService = class {
   async getRecordOrThrow(recordId) {
     const record = await this.getRecord(recordId);
     if (!record) {
-      throw new Error(`Record with id "${recordId}" not found`);
+      throw new RecordNotFoundError(recordId);
     }
     return record;
   }
@@ -4329,6 +5113,9 @@ var RecordService = class {
       if (!options?.skipRelationValidation) {
         await this.relationService.validateRelationsOrThrow(schema, data);
       }
+      if (!options?.skipUserValidation) {
+        await this.userService.validateUsersOrThrow(schema, data);
+      }
     }
     const completionStatus = computeRecordStatus(schema, mergedData);
     const label = await this.computeLabel(schema, mergedData);
@@ -4454,7 +5241,7 @@ var RecordService = class {
     await this.checkPermission(schema.name, "delete");
     if (options?.checkSystem) {
       if (schema.system) {
-        throw new Error(`Cannot delete record of system object "${schema.label}"`);
+        throw new ProtectedResourceError("object", schema.name, "delete");
       }
     }
     if (!options?.skipReferenceCheck) {
@@ -4503,7 +5290,11 @@ var RecordService = class {
   async restoreRecord(recordId, options) {
     const record = await this.getRecordOrThrow(recordId);
     if (!record.deletedAt) {
-      throw new Error(`Record "${recordId}" is not deleted`);
+      throw new SchemaError(
+        `Record "${recordId}" is not deleted`,
+        SchemaErrorCode.VALIDATION_FAILED,
+        { recordId, reason: "not_deleted" }
+      );
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
     await this.checkPermission(schema.name, "update");
@@ -4941,11 +5732,17 @@ var ViewService = class {
     this.validateViewName(input.name);
     const existing = await this.adapter.views.findByName(tenantId, input.objectName, input.name);
     if (existing) {
-      throw new Error(`View "${input.name}" already exists for object "${input.objectName}"`);
+      throw new SchemaError(
+        `View "${input.name}" already exists for object "${input.objectName}"`,
+        SchemaErrorCode.DUPLICATE_ATTRIBUTE,
+        { viewName: input.name, objectName: input.objectName }
+      );
     }
     if (this.nativeViews.has(input.objectName, input.name)) {
-      throw new Error(
-        `Cannot create view "${input.name}": a system view with this name already exists`
+      throw new SchemaError(
+        `Cannot create view "${input.name}": a system view with this name already exists`,
+        SchemaErrorCode.DUPLICATE_ATTRIBUTE,
+        { viewName: input.name, objectName: input.objectName, system: true }
       );
     }
     const dbView = await this.adapter.views.create({
@@ -4973,10 +5770,10 @@ var ViewService = class {
   async updateView(viewId, input) {
     const dbView = await this.adapter.views.findById(viewId);
     if (!dbView) {
-      throw new Error(`View with id "${viewId}" not found`);
+      throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new Error("Cannot modify system views. System views are protected.");
+      throw new ProtectedResourceError("view", dbView.name, "modify");
     }
     const updated = await this.adapter.views.update(viewId, {
       label: input.label,
@@ -4996,10 +5793,10 @@ var ViewService = class {
   async deleteView(viewId) {
     const dbView = await this.adapter.views.findById(viewId);
     if (!dbView) {
-      throw new Error(`View with id "${viewId}" not found`);
+      throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new Error("Cannot delete system views. System views are protected.");
+      throw new ProtectedResourceError("view", dbView.name, "delete");
     }
     await this.adapter.views.delete(viewId);
   }
@@ -5013,7 +5810,7 @@ var ViewService = class {
   async setDefaultView(viewId, tenantId) {
     const dbView = await this.adapter.views.findById(viewId);
     if (!dbView) {
-      throw new Error(`View with id "${viewId}" not found`);
+      throw new NotFoundError("View", viewId);
     }
     const currentViews = await this.adapter.views.findByObjectName(tenantId, dbView.objectName);
     for (const v of currentViews) {
@@ -5032,16 +5829,23 @@ var ViewService = class {
    */
   validateViewName(name) {
     if (!name || name.length === 0) {
-      throw new Error("View name cannot be empty");
+      throw new ValidationError("View name cannot be empty", [
+        { path: ["name"], message: "View name cannot be empty" }
+      ]);
     }
     if (name.length > 63) {
-      throw new Error("View name is too long (max 63 characters)");
+      throw new ValidationError("View name is too long", [
+        { path: ["name"], message: "View name is too long (max 63 characters)" }
+      ]);
     }
     const kebabCaseRegex = /^[a-z][a-z0-9-]*$/;
     if (!kebabCaseRegex.test(name)) {
-      throw new Error(
-        "Invalid view name format. Name must be in kebab-case (e.g., 'detail', 'list-view')"
-      );
+      throw new ValidationError("Invalid view name format", [
+        {
+          path: ["name"],
+          message: "View name must be in kebab-case (e.g., 'detail', 'list-view')"
+        }
+      ]);
     }
   }
   /**
@@ -5418,9 +6222,11 @@ var NoopGeocodingAdapter = class {
   RecordService,
   RelationService,
   UserProfileService,
+  UserService,
   ViewService,
   buildAuditChanges,
   createMockAdapter,
+  enrichValuesWithSelectLabels,
   extractAttributeNames,
   getSyncPreview,
   getViewSyncPreview,