@stndrds/schema 0.1.0-alpha.58 → 0.1.0-alpha.60

package/dist/{chunk-JRY236AO.mjs → chunk-RRCPZUSK.mjs}

@@ -307,8 +307,8 @@ var cacheKeys = {
   searchResults: (tenantId, objectId, hash) => `search:${tenantId}:${objectId}:${hash}`,
   /** All search results for an object (for invalidation) */
   allSearchResults: (tenantId, objectId) => `search:${tenantId}:${objectId}:*`,
-  /** Global search results */
-  globalSearch: (tenantId, hash) => `gsearch:${tenantId}:${hash}`,
+  /** Global search results (3-param signature to match cachedList pattern) */
+  globalSearch: (tenantId, _id, hash) => `gsearch:${tenantId}:${hash}`,
   /** All global search results for tenant (for invalidation) */
   allGlobalSearch: (tenantId) => `gsearch:${tenantId}:*`,
   // -------------------------------------------------------------------------
@@ -3949,7 +3949,6 @@ function createMockObjectRecordsRepository(stores) {
           objectLabel: obj?.label ?? "Unknown",
           label: renderLabelExpression(labelExpression, enrichedValues),
           recordId: r.id,
-          values: r.values,
           completionStatus: r.completionStatus,
           createdAt: r.createdAt,
           updatedAt: r.updatedAt
@@ -3957,6 +3956,36 @@ function createMockObjectRecordsRepository(stores) {
       });
       return Promise.resolve({ results, total });
     },
+    globalSearchGrouped(query, options) {
+      const limitPerGroup = options?.limitPerGroup ?? 5;
+      return this.globalSearch(query, {
+        objectNames: options?.objectNames,
+        limit: 500,
+        offset: 0
+      }).then(({ results }) => {
+        const groupMap = /* @__PURE__ */ new Map();
+        for (const result of results) {
+          let group2 = groupMap.get(result.objectName);
+          if (!group2) {
+            group2 = {
+              objectName: result.objectName,
+              objectLabel: result.objectLabel,
+              results: [],
+              totalInGroup: 0
+            };
+            groupMap.set(result.objectName, group2);
+          }
+          group2.totalInGroup++;
+          if (group2.results.length < limitPerGroup) {
+            group2.results.push(result);
+          }
+        }
+        const groups = Array.from(groupMap.values());
+        groups.sort((a, b) => b.totalInGroup - a.totalInGroup);
+        const total = groups.reduce((sum, g) => sum + g.totalInGroup, 0);
+        return { groups, total };
+      });
+    },
     // -------------------------------------------------------------------------
     // Schema Integrity Methods
     // -------------------------------------------------------------------------
@@ -4059,6 +4088,91 @@ function createMockObjectRecordsRepository(stores) {
   };
 }
 
+// src/runtime/mock/mock-relation-attributes.ts
+import { randomUUID } from "crypto";
+function createMockRelationAttributesRepository(stores) {
+  return {
+    async upsertBatch(items) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      const results = [];
+      for (const item of items) {
+        const _key = `${context.tenantId}:${item.fromObject}:${item.fromId}:${item.fromAttribute}:${item.toId}`;
+        const existing = Array.from(stores.relationAttributes.values()).find(
+          (row) => row.tenantId === context.tenantId && row.fromObject === item.fromObject && row.fromId === item.fromId && row.fromAttribute === item.fromAttribute && row.toId === item.toId
+        );
+        if (existing) {
+          existing.properties = item.properties ?? {};
+          existing.updatedAt = /* @__PURE__ */ new Date();
+          existing.updatedBy = item.updatedBy ?? context.userId ?? null;
+          results.push(existing);
+        } else {
+          const row = {
+            id: randomUUID(),
+            tenantId: context.tenantId,
+            fromObject: item.fromObject,
+            fromId: item.fromId,
+            fromAttribute: item.fromAttribute,
+            toId: item.toId,
+            properties: item.properties ?? {},
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            createdBy: item.createdBy ?? context.userId ?? null,
+            updatedBy: item.updatedBy ?? context.userId ?? null
+          };
+          stores.relationAttributes.set(row.id, row);
+          results.push(row);
+        }
+      }
+      return results;
+    },
+    async findBySource(fromObject, fromId, fromAttribute) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      return Array.from(stores.relationAttributes.values()).filter(
+        (row) => row.tenantId === context.tenantId && row.fromObject === fromObject && row.fromId === fromId && row.fromAttribute === fromAttribute
+      );
+    },
+    async findByTarget(toId) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      return Array.from(stores.relationAttributes.values()).filter(
+        (row) => row.tenantId === context.tenantId && row.toId === toId
+      );
+    },
+    async deleteBySource(fromObject, fromId, fromAttribute) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      const toDelete = Array.from(stores.relationAttributes.entries()).filter(
+        ([_id, row]) => row.tenantId === context.tenantId && row.fromObject === fromObject && row.fromId === fromId && row.fromAttribute === fromAttribute
+      );
+      for (const [id] of toDelete) {
+        stores.relationAttributes.delete(id);
+      }
+    },
+    async deleteByTarget(toId) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      const toDelete = Array.from(stores.relationAttributes.entries()).filter(
+        ([_id, row]) => row.tenantId === context.tenantId && row.toId === toId
+      );
+      for (const [id] of toDelete) {
+        stores.relationAttributes.delete(id);
+      }
+    }
+  };
+}
+
 // src/runtime/mock/mock-stores.ts
 function createEmptyStores() {
   return {
@@ -4079,7 +4193,8 @@ function createEmptyStores() {
     aiConversations: /* @__PURE__ */ new Map(),
     aiMessages: /* @__PURE__ */ new Map(),
     aiUserMemory: /* @__PURE__ */ new Map(),
-    aiUsageMetrics: /* @__PURE__ */ new Map()
+    aiUsageMetrics: /* @__PURE__ */ new Map(),
+    relationAttributes: /* @__PURE__ */ new Map()
   };
 }
 
@@ -4994,6 +5109,8 @@ function createMockAdapter() {
     aiConversations: createMockAIConversationsRepository(stores),
     aiUserMemory: createMockAIUserMemoryRepository(stores),
     aiUsageMetrics: createMockAIUsageMetricsRepository(stores),
+    // Relation attributes repository
+    relationAttributes: createMockRelationAttributesRepository(stores),
     async transaction(callback) {
       return await callback(adapter);
     },
@@ -5019,6 +5136,7 @@ function createMockAdapter() {
       stores.aiMessages.clear();
       stores.aiUserMemory.clear();
       stores.aiUsageMetrics.clear();
+      stores.relationAttributes.clear();
     }
   };
   return adapter;
@@ -5497,6 +5615,292 @@ function validateOptions(options, attributeName) {
   }
 }
 
+// src/types/relation-properties.ts
+var FORBIDDEN_PROPERTY_TYPES = [
+  "formula",
+  "rollup",
+  "relation",
+  "file",
+  "user",
+  "document",
+  "richtext"
+];
+
+// src/builders/property-schema-builder.ts
+var PropertySchemaBuilder = class {
+  constructor() {
+    this.definitions = [];
+  }
+  /**
+   * Add a property to the schema
+   * The type of property is automatically detected based on the builder methods used
+   */
+  add(name, configure) {
+    const builder = new PropertyTypeBuilder(name);
+    const configured = configure(builder);
+    const definition = configured.build();
+    this.definitions.push(definition);
+    return this;
+  }
+  /**
+   * Build the final PropertySchema
+   */
+  build() {
+    return {
+      definitions: this.definitions
+    };
+  }
+};
+var PropertyTypeBuilder = class {
+  constructor(name) {
+    this.name = name;
+  }
+  // Explicit type constructors
+  text() {
+    return new TextPropertyBuilder(this.name);
+  }
+  textarea() {
+    return new TextareaPropertyBuilder(this.name);
+  }
+  number() {
+    return new NumberPropertyBuilder(this.name);
+  }
+  checkbox() {
+    return new CheckboxPropertyBuilder(this.name);
+  }
+  date() {
+    return new DatePropertyBuilder(this.name);
+  }
+  phone() {
+    return new PhonePropertyBuilder(this.name);
+  }
+  currency() {
+    return new CurrencyPropertyBuilder(this.name);
+  }
+  status() {
+    return new StatusPropertyBuilder(this.name);
+  }
+  select() {
+    return new SelectPropertyBuilder(this.name);
+  }
+  multiselect() {
+    return new MultiselectPropertyBuilder(this.name);
+  }
+  rating() {
+    return new RatingPropertyBuilder(this.name);
+  }
+  location() {
+    return new LocationPropertyBuilder(this.name);
+  }
+};
+var BasePropertyBuilder = class {
+  constructor(name) {
+    this.definition = { name };
+  }
+  /**
+   * Set the label
+   */
+  label(label) {
+    this.definition.label = label;
+    return this;
+  }
+  /**
+   * Mark as required
+   */
+  required() {
+    this.definition.required = true;
+    return this;
+  }
+  /**
+   * Set description
+   */
+  description(description) {
+    this.definition.description = description;
+    return this;
+  }
+  /**
+   * Build the final definition
+   */
+  build() {
+    return this.definition;
+  }
+};
+var TextPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "text";
+  }
+  minLength(value) {
+    this.definition.minLength = value;
+    return this;
+  }
+  maxLength(value) {
+    this.definition.maxLength = value;
+    return this;
+  }
+  pattern(pattern) {
+    this.definition.pattern = pattern;
+    return this;
+  }
+  placeholder(value) {
+    this.definition.placeholder = value;
+    return this;
+  }
+};
+var TextareaPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "textarea";
+  }
+  minLength(value) {
+    this.definition.minLength = value;
+    return this;
+  }
+  maxLength(value) {
+    this.definition.maxLength = value;
+    return this;
+  }
+  placeholder(value) {
+    this.definition.placeholder = value;
+    return this;
+  }
+};
+var NumberPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "number";
+  }
+  min(value) {
+    this.definition.min = value;
+    return this;
+  }
+  max(value) {
+    this.definition.max = value;
+    return this;
+  }
+  decimal(places) {
+    this.definition.decimal = places;
+    return this;
+  }
+  integer() {
+    this.definition.integer = true;
+    return this;
+  }
+  placeholder(value) {
+    this.definition.placeholder = value;
+    return this;
+  }
+};
+var CheckboxPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "checkbox";
+  }
+};
+var DatePropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "date";
+  }
+  includeTime() {
+    this.definition.includeTime = true;
+    return this;
+  }
+  min(date2) {
+    this.definition.min = date2;
+    return this;
+  }
+  max(date2) {
+    this.definition.max = date2;
+    return this;
+  }
+};
+var PhonePropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "phone";
+  }
+};
+var CurrencyPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "currency";
+  }
+  currency(code) {
+    this.definition.currency = code;
+    return this;
+  }
+  min(value) {
+    this.definition.min = value;
+    return this;
+  }
+  max(value) {
+    this.definition.max = value;
+    return this;
+  }
+};
+var StatusPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "status";
+  }
+  options(options) {
+    this.definition.options = options;
+    return this;
+  }
+};
+var SelectPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "select";
+  }
+  options(options) {
+    this.definition.options = options;
+    return this;
+  }
+};
+var MultiselectPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "multiselect";
+  }
+  options(options) {
+    this.definition.options = options;
+    return this;
+  }
+  maxSelections(value) {
+    this.definition.maxSelections = value;
+    return this;
+  }
+};
+var RatingPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "rating";
+  }
+  max(value) {
+    this.definition.max = value;
+    return this;
+  }
+  icon(icon) {
+    this.definition.icon = icon;
+    return this;
+  }
+};
+var LocationPropertyBuilder = class extends BasePropertyBuilder {
+  constructor(name) {
+    super(name);
+    this.definition.type = "location";
+  }
+};
+function validatePropertyType(type) {
+  if (FORBIDDEN_PROPERTY_TYPES.includes(type)) {
+    throw new Error(
+      `Property type "${type}" is not supported in .qualifyWith(). Only simple types (text, number, date, select, etc.) are allowed. Complex types (formula, rollup, relation, file, user, document) would require duplicating backend behavior.`
+    );
+  }
+}
+
 // src/builders/attribute-builders.ts
 var BaseAttributeBuilder = class {
   constructor(type, name, label) {
@@ -6053,6 +6457,32 @@ var SingleRelationAttributeBuilder = class extends BaseAttributeBuilder {
     );
     return multiBuilder;
   }
+  /**
+   * Add properties to qualify the relation
+   * Must be called AFTER .to() to ensure targets are defined
+   *
+   * @example
+   * ```typescript
+   * relation({ name: "mainCompany", label: "Main Company" })
+   *   .to("companies")
+   *   .qualifyWith(props => props
+   *     .add("role", select => select.options([...]).required())
+   *     .add("shares", number => number.min(0))
+   *   )
+   * ```
+   */
+  qualifyWith(configure) {
+    const targets = this.attr.targets;
+    if (!targets || targets.length === 0) {
+      throw new Error(
+        '.qualifyWith() must be called AFTER .to(). Example: relation({ name: "mainCompany" }).to("companies").qualifyWith(...)'
+      );
+    }
+    const builder = new PropertySchemaBuilder();
+    const schema = configure(builder).build();
+    this.attr.properties = schema;
+    return this;
+  }
   required() {
     this.setRequired(true);
     return this;
@@ -6114,6 +6544,33 @@ var MultiRelationAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.maxItems = count;
     return this;
   }
+  /**
+   * Add properties to qualify the relation
+   * Must be called AFTER .to() or .many() to ensure targets are defined
+   *
+   * @example
+   * ```typescript
+   * relation({ name: "companies", label: "Companies" })
+   *   .to("companies")
+   *   .many()
+   *   .qualifyWith(props => props
+   *     .add("role", select => select.options([...]).required())
+   *     .add("shares", number => number.min(0))
+   *   )
+   * ```
+   */
+  qualifyWith(configure) {
+    const targets = this.attr.targets;
+    if (!targets || targets.length === 0) {
+      throw new Error(
+        '.qualifyWith() must be called AFTER .to() or .many(). Example: relation({ name: "companies" }).to("companies").many().qualifyWith(...)'
+      );
+    }
+    const builder = new PropertySchemaBuilder();
+    const schema = configure(builder).build();
+    this.attr.properties = schema;
+    return this;
+  }
   required() {
     this.setRequired(true);
     return this;
@@ -6499,7 +6956,7 @@ function object(config) {
 }
 
 // src/builders/view-builder.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { z as z3 } from "zod";
 var GroupBuilder = class {
   constructor(id, label) {
@@ -7359,7 +7816,7 @@ var ListViewBuilder = class {
       columns: this.data.columns,
       columnSizing: this.data.columnSizing,
       defaultFilters: this.data.defaultFilters ? {
-        id: randomUUID(),
+        id: randomUUID2(),
         combinator: this.data.defaultFilters.combinator,
         rules: this.data.defaultFilters.rules
       } : void 0,
@@ -7370,7 +7827,7 @@ var ListViewBuilder = class {
         label: tab.label,
         icon: tab.icon,
         filters: tab.filters ? {
-          id: randomUUID(),
+          id: randomUUID2(),
           combinator: tab.filters.combinator,
           rules: tab.filters.rules
         } : void 0,
@@ -9799,6 +10256,13 @@ var RecordQueryService = class extends BaseService {
       effectiveTotal = exhausted ? collected.length : Math.max(collected.length, result.total);
       filteredRecords = collected.slice(requestedOffset, requestedOffset + requestedLimit);
     }
+    if (options?.include && options.include.length > 0) {
+      filteredRecords = await this.includeRelationsWithProperties(
+        filteredRecords,
+        schema,
+        options.include
+      );
+    }
     if (!options?.skipFormulas) {
       return {
         records: enrichRecordsWithFormulas(filteredRecords, schema),
@@ -9874,6 +10338,79 @@ var RecordQueryService = class extends BaseService {
     }
     return result;
   }
+  // ============================================================================
+  // INCLUDE RELATIONS WITH PROPERTIES
+  // ============================================================================
+  /**
+   * Include relation properties in records.
+   *
+   * For each requested relation attribute:
+   * - If attribute has properties → Fetch from relation_attributes and return hybrid format
+   * - If attribute has NO properties → Return legacy format (string[] or string)
+   *
+   * Uses batch loading to avoid N+1 queries.
+   *
+   * @param records - Records to enrich with relation properties
+   * @param schema - Object schema
+   * @param includes - Array of relation attribute names to include
+   * @returns Records enriched with relation properties in hybrid format
+   * @private
+   */
+  async includeRelationsWithProperties(records, schema, includes) {
+    if (records.length === 0 || includes.length === 0) {
+      return records;
+    }
+    for (const includeName of includes) {
+      const attr = schema.attributes.find((a) => a.name === includeName);
+      if (!attr || attr.type !== "relation") {
+        continue;
+      }
+      if (attr.properties && this.adapter.relationAttributes) {
+        const recordIds = records.map((r) => r.id);
+        const relationAttributesRepo = this.adapter.relationAttributes;
+        const allRelationProps = await Promise.all(
+          recordIds.map(
+            (recordId) => relationAttributesRepo.findBySource(schema.name, recordId, includeName)
+          )
+        );
+        const propsByRecord = /* @__PURE__ */ new Map();
+        allRelationProps.forEach((props, index) => {
+          const recordId = recordIds[index];
+          const propsMap = /* @__PURE__ */ new Map();
+          for (const prop of props) {
+            propsMap.set(prop.toId, prop.properties);
+          }
+          propsByRecord.set(recordId, propsMap);
+        });
+        for (const record of records) {
+          const currentValue = record.values[includeName];
+          const propsMap = propsByRecord.get(record.id);
+          if (!currentValue) {
+            continue;
+          }
+          if (!propsMap) {
+            continue;
+          }
+          if (attr.cardinality === "many" && Array.isArray(currentValue)) {
+            record.values[includeName] = currentValue.map((id) => {
+              if (typeof id === "string") {
+                const props = propsMap.get(id);
+                return props ? { id, props } : { id };
+              }
+              return id;
+            });
+          } else if (attr.cardinality === "one") {
+            const id = typeof currentValue === "string" ? currentValue : null;
+            if (id) {
+              const props = propsMap.get(id);
+              record.values[includeName] = props ? { id, props } : { id };
+            }
+          }
+        }
+      }
+    }
+    return records;
+  }
 };
 
 // src/runtime/services/record/record-resolver.service.ts
@@ -9968,6 +10505,280 @@ var RecordResolverService = class extends BaseService {
   }
 };
 
+// src/runtime/services/record/relation-properties.service.ts
+import { z as z5 } from "zod";
+var RelationPropertiesService = class extends BaseService {
+  constructor(adapter) {
+    super(adapter);
+  }
+  // ============================================================================
+  // PUBLIC API
+  // ============================================================================
+  /**
+   * Normalize relation values for storage in object_records table.
+   *
+   * Extracts IDs from hybrid format ({ id, props }) and returns legacy format (string[] or string).
+   * This ensures object_records.values only contains IDs, while properties are in relation_attributes.
+   *
+   * @param schema - Object schema
+   * @param data - Record data with hybrid relation values
+   * @returns Data with relation values normalized to ID-only format
+   */
+  normalizeRelationValuesForStorage(schema, data) {
+    const normalized = { ...data };
+    for (const attr of schema.attributes) {
+      if (attr.type !== "relation" || !attr.properties) {
+        continue;
+      }
+      const value = data[attr.name];
+      if (value === null || value === void 0) {
+        continue;
+      }
+      if (attr.cardinality === "many" && Array.isArray(value)) {
+        normalized[attr.name] = value.map((item) => {
+          if (typeof item === "string") return item;
+          if (typeof item === "object" && item !== null && "id" in item) {
+            return item.id;
+          }
+          return item;
+        });
+      } else if (typeof value === "object" && value !== null && "id" in value) {
+        normalized[attr.name] = value.id;
+      }
+    }
+    return normalized;
+  }
+  /**
+   * Synchronize relation properties for a given attribute.
+   *
+   * Handles:
+   * - Format normalization (legacy → new)
+   * - Validation of properties
+   * - Upsert for present IDs
+   * - Delete for absent IDs
+   *
+   * @param schema - Object schema
+   * @param recordId - Source record ID
+   * @param attributeName - Relation attribute name
+   * @param relationValue - Relation value (hybrid format)
+   * @param adapter - Database adapter
+   */
+  async syncRelationProperties(schema, recordId, attributeName, relationValue, adapter) {
+    const attribute = schema.attributes.find((a) => a.name === attributeName);
+    if (!attribute || attribute.type !== "relation") {
+      return;
+    }
+    if (!attribute.properties) {
+      return;
+    }
+    const normalized = this.normalizeRelationValue(relationValue);
+    for (const item of normalized) {
+      if (item.props) {
+        this.validateProperties(attribute.properties, item.props);
+      }
+    }
+    const existing = await adapter.relationAttributes?.findBySource(
+      schema.name,
+      recordId,
+      attributeName
+    );
+    const existingIds = new Set((existing ?? []).map((r) => r.toId));
+    const newIds = new Set(normalized.map((item) => item.id));
+    const toUpsert = normalized.filter((item) => item.props !== void 0);
+    const toDelete = Array.from(existingIds).filter((id) => !newIds.has(id));
+    if (toUpsert.length > 0 && adapter.relationAttributes) {
+      const inputs = toUpsert.map((item) => ({
+        fromObject: schema.name,
+        fromId: recordId,
+        fromAttribute: attributeName,
+        toId: item.id,
+        properties: item.props ?? {},
+        updatedBy: this.userId ?? void 0,
+        createdBy: this.userId ?? void 0
+      }));
+      await adapter.relationAttributes.upsertBatch(inputs);
+    }
+    if (toDelete.length > 0 && adapter.relationAttributes && existing) {
+      for (const toId of toDelete) {
+        const relation2 = existing.find((r) => r.toId === toId);
+        if (relation2) {
+        }
+      }
+      await adapter.relationAttributes.deleteBySource(schema.name, recordId, attributeName);
+      if (toUpsert.length > 0) {
+        const inputs = toUpsert.map((item) => ({
+          fromObject: schema.name,
+          fromId: recordId,
+          fromAttribute: attributeName,
+          toId: item.id,
+          properties: item.props ?? {},
+          updatedBy: this.userId ?? void 0,
+          createdBy: this.userId ?? void 0
+        }));
+        await adapter.relationAttributes.upsertBatch(inputs);
+      }
+    }
+  }
+  /**
+   * Validate relation properties against PropertySchema.
+   *
+   * Uses Zod for runtime validation based on PropertyDefinition types.
+   *
+   * @param propertySchema - Schema defining allowed properties
+   * @param properties - Properties to validate
+   * @throws {z.ZodError} if validation fails
+   */
+  validateProperties(propertySchema, properties) {
+    const schema = this.buildZodSchema(propertySchema);
+    schema.parse(properties);
+  }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
+  /**
+   * Normalize relation value to unified internal format.
+   *
+   * Converts:
+   * - string[] → Array<{ id, props?: undefined }>
+   * - string → [{ id, props?: undefined }]
+   * - null → []
+   * - Array<{ id, props }> → Array<{ id, props }> (passthrough)
+   * - { id, props } → [{ id, props }] (single to array)
+   *
+   * @param value - Relation value in hybrid format
+   * @returns Normalized array of relation items
+   * @private
+   */
+  normalizeRelationValue(value) {
+    if (value === null || value === void 0) {
+      return [];
+    }
+    if (typeof value === "string") {
+      return [{ id: value }];
+    }
+    if (!Array.isArray(value) && typeof value === "object" && "id" in value) {
+      return [value];
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => {
+        if (typeof item === "string") {
+          return { id: item };
+        }
+        return item;
+      });
+    }
+    return [];
+  }
+  /**
+   * Build Zod schema from PropertySchema definition.
+   *
+   * Dynamically generates validation schema based on PropertyDefinition types.
+   *
+   * @param propertySchema - PropertySchema with definitions
+   * @returns Zod schema for validation
+   * @private
+   */
+  buildZodSchema(propertySchema) {
+    const shape = {};
+    for (const def of propertySchema.definitions) {
+      let fieldSchema = this.buildFieldSchema(def);
+      if (!def.required) {
+        fieldSchema = fieldSchema.optional();
+      }
+      shape[def.name] = fieldSchema;
+    }
+    return z5.object(shape);
+  }
+  /**
+   * Build Zod schema for a single property field.
+   *
+   * @param def - PropertyDefinition
+   * @returns Zod schema for the field
+   * @private
+   */
+  buildFieldSchema(def) {
+    switch (def.type) {
+      case "text":
+      case "textarea": {
+        let schema = z5.string();
+        if (def.minLength !== void 0) {
+          schema = schema.min(def.minLength);
+        }
+        if (def.maxLength !== void 0) {
+          schema = schema.max(def.maxLength);
+        }
+        if (def.type === "text" && def.pattern) {
+          schema = schema.regex(new RegExp(def.pattern));
+        }
+        return schema;
+      }
+      case "number": {
+        let schema = z5.number();
+        if (def.min !== void 0) {
+          schema = schema.min(def.min);
+        }
+        if (def.max !== void 0) {
+          schema = schema.max(def.max);
+        }
+        if (def.integer) {
+          schema = schema.int();
+        }
+        return schema;
+      }
+      case "checkbox": {
+        return z5.boolean();
+      }
+      case "date": {
+        const schema = z5.string().datetime();
+        return schema;
+      }
+      case "phone": {
+        return z5.string();
+      }
+      case "currency": {
+        let schema = z5.number();
+        if (def.min !== void 0) {
+          schema = schema.min(def.min);
+        }
+        if (def.max !== void 0) {
+          schema = schema.max(def.max);
+        }
+        return schema;
+      }
+      case "status":
+      case "select": {
+        const validValues = def.options.map((opt) => opt.value);
+        return z5.enum(validValues);
+      }
+      case "multiselect": {
+        const validValues = def.options.map((opt) => opt.value);
+        let schema = z5.array(z5.enum(validValues));
+        if (def.maxSelections !== void 0) {
+          schema = schema.max(def.maxSelections);
+        }
+        return schema;
+      }
+      case "rating": {
+        let schema = z5.number().int();
+        if (def.max !== void 0) {
+          schema = schema.max(def.max);
+        }
+        return schema.min(0);
+      }
+      case "location": {
+        return z5.object({
+          address: z5.string().optional(),
+          lat: z5.number().optional(),
+          lng: z5.number().optional()
+        });
+      }
+      default: {
+        return z5.unknown();
+      }
+    }
+  }
+};
+
 // src/runtime/services/record/relation.service.ts
 var RelationService = class extends BaseService {
   constructor(adapter, nativeRegistry, options) {
@@ -10796,6 +11607,7 @@ var RecordService = class extends BaseService {
       queryService: this.queryService,
       recordResolver: this.recordResolver
     });
+    this.relationPropertiesService = new RelationPropertiesService(adapter);
     this.rollupService = new RollupService(adapter, {
       recordResolver: this.recordResolver
     });
@@ -10840,29 +11652,45 @@ var RecordService = class extends BaseService {
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("beforeCreate", schema.name, hookCtx);
     }
+    const normalizedData = this.relationPropertiesService.normalizeRelationValuesForStorage(
+      schema,
+      dataWithDefaults
+    );
     if (options?.validate !== false) {
       if (options?.allowDraft) {
-        validateDraftOrThrow(schema, dataWithDefaults);
+        validateDraftOrThrow(schema, normalizedData);
       } else {
-        validateObjectOrThrow(schema, dataWithDefaults);
+        validateObjectOrThrow(schema, normalizedData);
       }
       if (!options?.skipRelationValidation) {
-        await this.relationService.validateRelationsOrThrow(schema, dataWithDefaults);
+        await this.relationService.validateRelationsOrThrow(schema, normalizedData);
       }
       if (!options?.skipUserValidation) {
-        await this.userService.validateUsersOrThrow(schema, dataWithDefaults);
+        await this.userService.validateUsersOrThrow(schema, normalizedData);
       }
     }
-    const completionStatus = computeRecordStatus(schema, dataWithDefaults);
-    const label = await computeLabel(schema, dataWithDefaults, this.labelResolver);
+    const completionStatus = computeRecordStatus(schema, normalizedData);
+    const label = await computeLabel(schema, normalizedData, this.labelResolver);
     const record = await this.adapter.objectRecords.create({
       objectId,
-      data: dataWithDefaults,
+      data: normalizedData,
       label,
       completionStatus,
       metadata: options?.metadata,
       createdBy: this.userId
     });
+    for (const [attrName, value] of Object.entries(dataWithDefaults)) {
+      const attr = schema.attributes.find((a) => a.name === attrName);
+      if (attr?.type === "relation" && attr.properties) {
+        await this.relationPropertiesService.syncRelationProperties(
+          schema,
+          record.id,
+          attrName,
+          value,
+          this.adapter
+        );
+      }
+    }
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -10993,30 +11821,29 @@ var RecordService = class extends BaseService {
         hookModifiedValues[key] = hookCtx.newValues[key];
       }
     }
+    const dataToUpdate = { ...data, ...hookModifiedValues };
+    const normalizedUpdate = this.relationPropertiesService.normalizeRelationValuesForStorage(
+      schema,
+      dataToUpdate
+    );
+    const normalizedMergedData = { ...existing.values, ...normalizedUpdate };
     if (options?.validate !== false) {
       if (options?.partial) {
-        validateDraftOrThrow(schema, mergedData);
+        validateDraftOrThrow(schema, normalizedMergedData);
       } else {
-        validateObjectOrThrow(schema, mergedData);
+        validateObjectOrThrow(schema, normalizedMergedData);
       }
       if (!options?.skipRelationValidation) {
-        await this.relationService.validateRelationsOrThrow(schema, {
-          ...data,
-          ...hookModifiedValues
-        });
+        await this.relationService.validateRelationsOrThrow(schema, normalizedUpdate);
       }
       if (!options?.skipUserValidation) {
-        await this.userService.validateUsersOrThrow(schema, {
-          ...data,
-          ...hookModifiedValues
-        });
+        await this.userService.validateUsersOrThrow(schema, normalizedUpdate);
       }
     }
-    const completionStatus = computeRecordStatus(schema, mergedData);
-    const label = await computeLabel(schema, mergedData, this.labelResolver);
+    const completionStatus = computeRecordStatus(schema, normalizedMergedData);
+    const label = await computeLabel(schema, normalizedMergedData, this.labelResolver);
     const updatePayload = {
-      ...data,
-      ...hookModifiedValues,
+      ...normalizedUpdate,
       __completionStatus: completionStatus,
       __label: label,
       __lastUpdatedBy: this.userId,
@@ -11032,6 +11859,18 @@ var RecordService = class extends BaseService {
     }
     const updated = await this.adapter.objectRecords.update(recordId, updatePayload);
     await this.invalidateRecordCaches(recordId, existing.objectId);
+    for (const [attrName, value] of Object.entries(dataToUpdate)) {
+      const attr = schema.attributes.find((a) => a.name === attrName);
+      if (attr?.type === "relation" && attr.properties) {
+        await this.relationPropertiesService.syncRelationProperties(
+          schema,
+          recordId,
+          attrName,
+          value,
+          this.adapter
+        );
+      }
+    }
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -15707,23 +16546,6 @@ var GlobalSearchService = class extends BaseService {
    * @param query - Search query string
    * @param options - Search options (pagination, object filters)
    * @returns Matching records with object metadata and total count
-   *
-   * @example
-   * ```typescript
-   * // Basic search
-   * const { results, total } = await service.search("nike air");
-   *
-   * // With pagination
-   * const { results, total } = await service.search("nike", {
-   *   limit: 10,
-   *   offset: 20
-   * });
-   *
-   * // Filter by object types
-   * const { results, total } = await service.search("nike", {
-   *   objectNames: ["products", "orders"]
-   * });
-   * ```
    */
   async search(query, options) {
     if (!query || query.trim().length === 0) {
@@ -15731,58 +16553,36 @@ var GlobalSearchService = class extends BaseService {
     }
     return this.cachedList(
       "globalSearch",
-      "global",
+      "search",
       { query: query.trim(), ...options },
-      () => this.executeSearch(query.trim(), options)
+      () => this.adapter.objectRecords.globalSearch(query.trim(), {
+        limit: options?.limit ?? 20,
+        offset: options?.offset ?? 0,
+        objectNames: options?.objectNames
+      })
     );
   }
   /**
-   * Internal search execution (extracted for caching)
-   */
-  async executeSearch(query, options) {
-    return await this.adapter.objectRecords.globalSearch(query, {
-      limit: options?.limit ?? 20,
-      offset: options?.offset ?? 0,
-      objectNames: options?.objectNames,
-      includeObjectInfo: options?.includeObjectInfo ?? true
-    });
-  }
-  /**
-   * Search and group results by object type
+   * Search and group results by object type.
+   * Delegates grouping to the database for accurate per-group counts.
    *
    * @param query - Search query string
-   * @param options - Search options
-   * @returns Results grouped by object name
+   * @param options - Search options (object filters, limit per group)
+   * @returns Results grouped by object name with per-group totals
    */
   async searchGrouped(query, options) {
-    const limitPerGroup = options?.limitPerGroup ?? 5;
-    const estimatedGroupCount = 10;
-    const fetchLimit = Math.min(limitPerGroup * estimatedGroupCount, 100);
-    const { results, total } = await this.search(query, {
-      ...options,
-      limit: fetchLimit,
-      offset: 0
-    });
-    const groupMap = /* @__PURE__ */ new Map();
-    for (const result of results) {
-      const existing = groupMap.get(result.objectName);
-      if (existing) {
-        existing.results.push(result);
-      } else {
-        groupMap.set(result.objectName, {
-          objectName: result.objectName,
-          objectLabel: result.objectLabel,
-          results: [result]
-        });
-      }
+    if (!query || query.trim().length === 0) {
+      return { groups: [], total: 0 };
     }
-    const groups = Array.from(groupMap.values()).map((g) => ({
-      ...g,
-      results: g.results.slice(0, limitPerGroup),
-      count: g.results.length
-    }));
-    groups.sort((a, b) => b.count - a.count);
-    return { groups, total };
+    return this.cachedList(
+      "globalSearch",
+      "grouped",
+      { query: query.trim(), ...options },
+      () => this.adapter.objectRecords.globalSearchGrouped(query.trim(), {
+        objectNames: options?.objectNames,
+        limitPerGroup: options?.limitPerGroup ?? 5
+      })
+    );
   }
 };
 
@@ -17132,6 +17932,7 @@ export {
   SYSTEM_FIELD_NAMES,
   RESERVED_ATTRIBUTE_NAMES,
   PolicyViolationError,
+  FORBIDDEN_PROPERTY_TYPES,
   SYSTEM_ATTRIBUTES,
   getSystemAttributeList,
   isSystemAttribute,
@@ -17230,6 +18031,22 @@ export {
   RoleNotFoundError,
   isForbiddenError,
   ConcurrentModificationError,
+  PropertySchemaBuilder,
+  PropertyTypeBuilder,
+  BasePropertyBuilder,
+  TextPropertyBuilder,
+  TextareaPropertyBuilder,
+  NumberPropertyBuilder,
+  CheckboxPropertyBuilder,
+  DatePropertyBuilder,
+  PhonePropertyBuilder,
+  CurrencyPropertyBuilder,
+  StatusPropertyBuilder,
+  SelectPropertyBuilder,
+  MultiselectPropertyBuilder,
+  RatingPropertyBuilder,
+  LocationPropertyBuilder,
+  validatePropertyType,
   text,
   textarea,
   richtext,
@@ -17399,6 +18216,7 @@ export {
   recalculateParentRollups,
   RecordQueryService,
   RecordResolverService,
+  RelationPropertiesService,
   RelationService,
   RollupService,
   RecordService,