@stndrds/schema 0.1.0-alpha.40 → 0.1.0-alpha.41

package/dist/{chunk-2C24E4Q2.mjs → chunk-4ZUAND4E.mjs}

@@ -482,7 +482,7 @@ var TenantContextError = class _TenantContextError extends Error {
   }
 };
 
-// src/runtime/context/tenant-context.ts
+// src/runtime/context/schema-context.ts
 var browserStub = {
   getStore: () => void 0,
   run: (_store, callback) => callback()
@@ -520,8 +520,102 @@ function getStorage() {
   storageInstance = browserStub;
   return storageInstance;
 }
-function getContext() {
+function getSchemaFromContext(objectId) {
+  const ctx = getStorage().getStore();
+  return ctx?.objectsById.get(objectId);
+}
+function getSchemaByNameFromContext(objectName) {
+  const ctx = getStorage().getStore();
+  return ctx?.objectsByName.get(objectName);
+}
+function hasSchemaContext() {
+  return getStorage().getStore() !== void 0;
+}
+function getSchemaContext() {
+  return getStorage().getStore();
+}
+function addSchemaToContext(schema) {
   const ctx = getStorage().getStore();
+  if (!ctx) {
+    return;
+  }
+  if (schema.id) {
+    ctx.objectsById.set(schema.id, schema);
+  }
+  ctx.objectsByName.set(schema.name, schema);
+}
+function buildSchemaContext(schemas) {
+  const objectsById = /* @__PURE__ */ new Map();
+  const objectsByName = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    if (schema.id) {
+      objectsById.set(schema.id, schema);
+    }
+    objectsByName.set(schema.name, schema);
+  }
+  return { objectsById, objectsByName };
+}
+function runWithSchemaContext(schemas, fn) {
+  const context = buildSchemaContext(schemas);
+  return getStorage().run(context, fn);
+}
+function runWithMergedSchemaContext(schemas, fn) {
+  const existing = getStorage().getStore();
+  const objectsById = new Map(existing?.objectsById);
+  const objectsByName = new Map(existing?.objectsByName);
+  for (const schema of schemas) {
+    if (schema.id) {
+      objectsById.set(schema.id, schema);
+    }
+    objectsByName.set(schema.name, schema);
+  }
+  const context = {
+    objectsById,
+    objectsByName
+  };
+  return getStorage().run(context, fn);
+}
+
+// src/runtime/context/tenant-context.ts
+var browserStub2 = {
+  getStore: () => void 0,
+  run: (_store, callback) => callback()
+};
+var AsyncLocalStorageClass2 = null;
+if (typeof process !== "undefined" && process.versions?.node) {
+  try {
+    if (typeof __require !== "undefined") {
+      const asyncHooks = __require("async_hooks");
+      AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+    }
+  } catch {
+    try {
+      const dynamicRequire = new Function(
+        "m",
+        'return typeof require!=="undefined"?require(m):null'
+      );
+      const asyncHooks = dynamicRequire("node:async_hooks");
+      if (asyncHooks) {
+        AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+      }
+    } catch {
+    }
+  }
+}
+var storageInstance2 = null;
+function getStorage2() {
+  if (storageInstance2 !== null) {
+    return storageInstance2;
+  }
+  if (AsyncLocalStorageClass2) {
+    storageInstance2 = new AsyncLocalStorageClass2();
+    return storageInstance2;
+  }
+  storageInstance2 = browserStub2;
+  return storageInstance2;
+}
+function getContext() {
+  const ctx = getStorage2().getStore();
   if (!ctx) {
     throw new TenantContextError();
   }
@@ -534,11 +628,11 @@ function getUserId() {
   return getContext().userId;
 }
 function hasContext() {
-  return getStorage().getStore() !== void 0;
+  return getStorage2().getStore() !== void 0;
 }
 function runWithContext(context, fn) {
   const frozenContext = Object.freeze({ ...context });
-  return getStorage().run(frozenContext, fn);
+  return getStorage2().run(frozenContext, fn);
 }
 function withTenantContext(tenantId, fn, userId) {
   return runWithContext({ tenantId, userId }, fn);
@@ -2315,8 +2409,14 @@ function formatCheckbox(value) {
 function formatNumber(value, attribute) {
   if (typeof value !== "number") return String(value);
   const decimals = attribute.decimals;
-  if (attribute.unit === "percentage") {
+  if (attribute.unit === "integer") {
     return value.toLocaleString(void 0, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 0
+    });
+  }
+  if (attribute.unit === "percentage") {
+    return (value / 100).toLocaleString(void 0, {
       style: "percent",
       minimumFractionDigits: decimals,
       maximumFractionDigits: decimals
@@ -4122,6 +4222,20 @@ var TenantAwareRepository = class {
     return getUserId();
   }
 };
+var SchemaContextAwareRepository = class extends TenantAwareRepository {
+  /**
+   * Get an ObjectDefinition from context by its ID.
+   */
+  getSchemaFromContext(objectId) {
+    return getSchemaFromContext(objectId);
+  }
+  /**
+   * Get an ObjectDefinition from context by its name.
+   */
+  getSchemaByNameFromContext(objectName) {
+    return getSchemaByNameFromContext(objectName);
+  }
+};
 
 // src/runtime/services/audit.service.ts
 var SENSITIVE_PATTERNS = [
@@ -9349,6 +9463,8 @@ var RelationService = class extends TenantAwareService {
   }
   /**
    * Validate a single relation attribute value
+   *
+   * Uses batch fetching (findByIds) to avoid N+1 query pattern.
    */
   async validateRelationAttribute(attr, value) {
     const errors = [];
@@ -9365,9 +9481,11 @@ var RelationService = class extends TenantAwareService {
       });
       return errors;
     }
+    const records = await this.adapter.objectRecords.findByIds(ids);
+    const recordMap = new Map(records.map((r) => [r.id, r]));
     const invalidIds = [];
     for (const id of ids) {
-      const record = await this.adapter.objectRecords.findById(id);
+      const record = recordMap.get(id);
       if (!record) {
         invalidIds.push(id);
         continue;
@@ -9681,22 +9799,37 @@ var RollupService = class {
       return { value: null, recordCount: 0 };
     }
     const sourceObjectName = rollupAttr.relationAttribute;
-    const sourceObject = await this.adapter.objects.findByName(sourceObjectName);
-    if (!sourceObject) {
-      return { value: null, recordCount: 0 };
+    const sourceSchema = getSchemaByNameFromContext(sourceObjectName);
+    let sourceObjectId;
+    let reverseRelationAttrName;
+    if (sourceSchema?.id) {
+      sourceObjectId = sourceSchema.id;
+      const reverseRelationAttr = sourceSchema.attributes.find((attr) => {
+        if (attr.type !== "relation") return false;
+        const relationConfig = attr;
+        return relationConfig?.targets?.some((t) => t.object === schema.name);
+      });
+      reverseRelationAttrName = reverseRelationAttr?.name;
+    } else {
+      const sourceObject = await this.adapter.objects.findByName(sourceObjectName);
+      if (!sourceObject) {
+        return { value: null, recordCount: 0 };
+      }
+      sourceObjectId = sourceObject.id;
+      const sourceAttributes = await this.adapter.attributes.findByObjectId(sourceObject.id);
+      const reverseRelationAttr = sourceAttributes.find((attr) => {
+        if (attr.type !== "relation") return false;
+        const relationConfig = attr.config;
+        return relationConfig?.targets?.some((t) => t.object === schema.name);
+      });
+      reverseRelationAttrName = reverseRelationAttr?.name;
     }
-    const sourceAttributes = await this.adapter.attributes.findByObjectId(sourceObject.id);
-    const reverseRelationAttr = sourceAttributes.find((attr) => {
-      if (attr.type !== "relation") return false;
-      const relationConfig = attr.config;
-      return relationConfig?.targets?.some((t) => t.object === schema.name);
-    });
-    if (!reverseRelationAttr) {
+    if (!reverseRelationAttrName) {
       return { value: null, recordCount: 0 };
     }
     const relatedRecords = await this.adapter.objectRecords.findByRelation(
-      sourceObject.id,
-      reverseRelationAttr.name,
+      sourceObjectId,
+      reverseRelationAttrName,
       recordId
     );
     if (relatedRecords.length === 0) {
@@ -10823,7 +10956,10 @@ var RecordService = class extends TenantAwareService {
     if (policy?.applyListFilter) {
       effectiveOptions = policy.applyListFilter(this.buildPolicyContext(schema.name), options);
     }
-    const result = await this.adapter.objectRecords.list(objectId, effectiveOptions);
+    const result = await runWithSchemaContext(
+      [schema],
+      () => this.adapter.objectRecords.list(objectId, effectiveOptions)
+    );
     let filteredRecords = result.records;
     let effectiveTotal = result.total;
     if (policy?.canAccessRecord) {
@@ -10855,7 +10991,10 @@ var RecordService = class extends TenantAwareService {
     if (this.permissionService && this.userId) {
       await this.checkPermission(schema.name, "read");
     }
-    const result = await this.adapter.objectRecords.search(objectId, query, options);
+    const result = await runWithSchemaContext(
+      [schema],
+      () => this.adapter.objectRecords.search(objectId, query, options)
+    );
     if (!options?.skipFormulas) {
       return {
         records: this.enrichRecordsWithFormulas(result.records, schema),
@@ -13362,6 +13501,13 @@ export {
   QueryNoResultError,
   QueryMultipleResultsError,
   TenantContextError,
+  getSchemaFromContext,
+  getSchemaByNameFromContext,
+  hasSchemaContext,
+  getSchemaContext,
+  addSchemaToContext,
+  runWithSchemaContext,
+  runWithMergedSchemaContext,
   getContext,
   getTenantId,
   getUserId,
@@ -13423,6 +13569,7 @@ export {
   buildAuditChanges,
   TenantAwareService,
   TenantAwareRepository,
+  SchemaContextAwareRepository,
   AuditService,
   FileService,
   GeocodingService,