@sixb/core 0.1.6 → 0.1.8

package/dist/{chunk-5sxb1168.js → chunk-aa2pen2v.js}

@@ -1,50 +1,50 @@
 // @bun
-import {
-  createObjectQueryBuilder
-} from "./chunk-4rh2m6zg.js";
 import {
   getOntologyMutationRuntime,
   shareOntologyMutationRuntime
 } from "./chunk-xhy826cz.js";
 import {
-  countObjects,
-  executeObjectQuery,
-  existsObjects,
+  createObjectQueryBuilder
+} from "./chunk-4rh2m6zg.js";
+import {
+  assertAuthorizedObjectReaderBinding,
+  getAuthorizedOntologyView,
+  requestAction,
+  requestActionAndWait
+} from "./chunk-h5vqbfmd.js";
+import {
   explainObjectQuery,
-  facetObjects,
   validateObjectQuery
-} from "./chunk-md8k0r54.js";
+} from "./chunk-q0k9nc5a.js";
 import {
   ObjectQueryPlanningError
 } from "./chunk-rte5sm3z.js";
-import {
-  RuntimeError,
-  requestAction,
-  requestActionAndWait
-} from "./chunk-a44d5zgd.js";
 import {
   normalizeJsonProperties
-} from "./chunk-nkbfrt0c.js";
+} from "./chunk-f26bck4t.js";
 import {
   ObjectNotFoundError,
   objectBatchKey
-} from "./chunk-t624af60.js";
+} from "./chunk-sbzzr4kx.js";
 import {
   linkRefKey,
   telemetryPointKey
-} from "./chunk-vybf6pkp.js";
+} from "./chunk-dbc80ad7.js";
 import {
   MaterializationObjectNotFoundError
 } from "./chunk-ry24jbr1.js";
+import {
+  RuntimeError
+} from "./chunk-p2vqaxkc.js";
 import {
   shareSixbErrorReporter
-} from "./chunk-dsrkgtnh.js";
+} from "./chunk-jq43kdvk.js";
 import {
   assertAuthorized,
   assertCanAppendTelemetry,
   assertCanEdit,
-  assertPrivileged
-} from "./chunk-f83ka50g.js";
+  resolveRuntimeAuthorizationForProject
+} from "./chunk-p1x242ad.js";
 import {
   assertKnownProperties,
   assertLinkTargetType,
@@ -55,14 +55,17 @@ import {
   normalizeObjectProperties,
   validateLinkProperties,
   validateObjectProperties
-} from "./chunk-rnshztfq.js";
+} from "./chunk-h0k55pc7.js";
 import {
   OntologyNotFoundError,
   OntologyValidationError
 } from "./chunk-dktq02ne.js";
+import {
+  createSixbError
+} from "./chunk-2xns679x.js";
 import {
   stableJsonStringify
-} from "./chunk-t8t39h7v.js";
+} from "./chunk-n6jxh8sw.js";
 import {
   __export
 } from "./chunk-y64skrwp.js";
@@ -540,16 +543,205 @@ async function appendTelemetryBatch(ctx, items) {
 
 // src/objects/telemetry/history.ts
 async function getTelemetryHistoryBatch(input, options) {
-  assertTelemetrySeriesViewable(input.series, options);
-  return options.storage.getHistoryBatch(input);
+  const objectReader = options.objectReader;
+  const storage = options.storage;
+  const projectId = objectReader.projectId;
+  const request = snapshotTelemetryHistoryInput(input, objectReader);
+  const uniqueSeries = deduplicateSeries(request.series);
+  const readableSeries = await selectReadableSeries(uniqueSeries, objectReader);
+  const resultsBySeries = await readAndValidateHistory({
+    storage,
+    projectId,
+    request,
+    series: readableSeries
+  });
+  const releasableSeries = readableSeries.length === 0 ? [] : await selectReadableSeries(readableSeries, objectReader);
+  const result = assembleHistoryResults({ request, resultsBySeries, releasableSeries });
+  objectReader.assertVisibleOutputWithinLimit(result);
+  return result;
+}
+async function getLatestTelemetryPoint(input, options) {
+  const objectReader = options.objectReader;
+  const storage = options.storage;
+  const projectId = objectReader.projectId;
+  const series = snapshotTelemetrySeries(input);
+  const readable = await objectReader.canReadObjectProperty(objectPropertySelection(series));
+  if (!readable)
+    return visibleLatestResult(null, objectReader);
+  const rawResult = await storage.getLatest({ projectId, ...series });
+  const result = rawResult === null ? null : snapshotProviderPoint(rawResult);
+  if (result)
+    assertTimeseriesPointMatchesSeries(projectId, series, result);
+  const releaseReadable = await objectReader.canReadObjectProperty(objectPropertySelection(series));
+  if (!releaseReadable)
+    return visibleLatestResult(null, objectReader);
+  return visibleLatestResult(result, objectReader);
 }
-function assertTelemetrySeriesViewable(series, authorization) {
-  for (const objectTypeId of new Set(series.map((entry) => entry.objectTypeId))) {
-    assertAuthorized({
-      runtimeAuthorization: authorization.runtimeAuthorization,
-      authorization: authorization.authorization ?? undefined
-    }, { kind: "object.view", objectTypeId });
+function deduplicateSeries(series) {
+  const uniqueSeries = new Map;
+  for (const item of series) {
+    const key = seriesKey(item);
+    if (!uniqueSeries.has(key))
+      uniqueSeries.set(key, item);
   }
+  return [...uniqueSeries.values()];
+}
+async function selectReadableSeries(series, objectReader) {
+  const readable = await objectReader.canReadObjectPropertiesBatch({
+    items: series.map(objectPropertySelection)
+  });
+  return series.filter((_, index) => readable[index] === true);
+}
+async function readAndValidateHistory(input) {
+  const { storage, projectId, request, series } = input;
+  const providerRequest = structuredClone({
+    projectId,
+    series,
+    ...request.from === undefined ? {} : { from: request.from },
+    ...request.to === undefined ? {} : { to: request.to },
+    ...request.limitPerSeries === undefined ? {} : { limitPerSeries: request.limitPerSeries },
+    ...request.order === undefined ? {} : { order: request.order }
+  });
+  const stored = series.length === 0 ? [] : await storage.getHistoryBatch(providerRequest);
+  if (!Array.isArray(stored))
+    throw invalidTimeseriesProviderResult();
+  const storedCount = stored.length;
+  if (!Number.isSafeInteger(storedCount) || storedCount > series.length) {
+    throw invalidTimeseriesProviderResult();
+  }
+  const seriesKeys = new Set(series.map(seriesKey));
+  const providerResultBySeries = new Map;
+  for (let index = 0;index < storedCount; index += 1) {
+    const providerResult = snapshotProviderResult(stored[index], request.limitPerSeries);
+    const key = seriesKey(providerResult);
+    if (providerResultBySeries.has(key) || !seriesKeys.has(key)) {
+      throw invalidTimeseriesProviderResult();
+    }
+    for (const point of providerResult.points) {
+      assertTimeseriesPointMatchesSeries(projectId, providerResult, point);
+    }
+    providerResultBySeries.set(key, providerResult);
+  }
+  return providerResultBySeries;
+}
+function assembleHistoryResults(input) {
+  const { request, resultsBySeries, releasableSeries } = input;
+  const releasableSeriesKeys = new Set(releasableSeries.map(seriesKey));
+  const releasedPoints = request.series.map((series) => releasableSeriesKeys.has(seriesKey(series)) ? resultsBySeries.get(seriesKey(series))?.points ?? [] : []);
+  const pointOccurrences = releasedPoints.reduce((total, points) => total + points.length, 0);
+  if (request.maxPointOccurrences !== undefined && pointOccurrences > request.maxPointOccurrences) {
+    throw invalidTimeseriesProviderResult();
+  }
+  return request.series.map((series, index) => ({
+    ...series,
+    points: releasedPoints[index].map((point) => structuredClone(point))
+  }));
+}
+function snapshotTelemetrySeries(series) {
+  if (typeof series !== "object" || series === null || Array.isArray(series)) {
+    throw new Error("[Sixb] Telemetry history series must be an object.");
+  }
+  const objectTypeId = telemetryIdentifier(series.objectTypeId, "objectTypeId");
+  const objectId = telemetryIdentifier(series.objectId, "objectId");
+  const propertyId = telemetryIdentifier(series.propertyId, "propertyId");
+  return structuredClone({ objectTypeId, objectId, propertyId });
+}
+function assertTimeseriesPointMatchesSeries(projectId, series, point) {
+  if (typeof point !== "object" || point === null || point.projectId !== projectId || point.objectTypeId !== series.objectTypeId || point.objectId !== series.objectId || point.propertyId !== series.propertyId) {
+    throw invalidTimeseriesProviderResult();
+  }
+}
+function snapshotTelemetryHistoryInput(input, objectReader) {
+  const authoredSeries = input.series;
+  const from = input.from;
+  const to = input.to;
+  const limitPerSeries = input.limitPerSeries;
+  const order = input.order;
+  if (!Array.isArray(authoredSeries)) {
+    throw new Error("[Sixb] Telemetry history series must be an array.");
+  }
+  if (order !== undefined && order !== "asc" && order !== "desc") {
+    throw new Error("[Sixb] Telemetry history order must be 'asc' or 'desc'.");
+  }
+  const seriesCount = authoredSeries.length;
+  const admission = objectReader.admitTelemetryHistoryRead({
+    seriesCount,
+    ...limitPerSeries === undefined ? {} : { limitPerSeries }
+  });
+  const series = [];
+  for (let index = 0;index < seriesCount; index += 1) {
+    series.push(snapshotTelemetrySeries(authoredSeries[index]));
+  }
+  return structuredClone({
+    series,
+    ...from === undefined ? {} : { from },
+    ...to === undefined ? {} : { to },
+    ...admission.limitPerSeries === undefined ? {} : { limitPerSeries: admission.limitPerSeries },
+    ...order === undefined ? {} : { order },
+    ...admission.maxPointOccurrences === undefined ? {} : { maxPointOccurrences: admission.maxPointOccurrences }
+  });
+}
+function objectPropertySelection(series) {
+  return {
+    objectTypeId: series.objectTypeId,
+    primaryId: series.objectId,
+    propertyId: series.propertyId
+  };
+}
+function visibleLatestResult(result, objectReader) {
+  objectReader.assertVisibleOutputWithinLimit(result);
+  return result;
+}
+function snapshotProviderResult(result, maxPointsPerSeries) {
+  try {
+    if (typeof result !== "object" || result === null || Array.isArray(result)) {
+      throw invalidTimeseriesProviderResult();
+    }
+    const series = snapshotTelemetrySeries(result);
+    const authoredPoints = result.points;
+    if (!Array.isArray(authoredPoints))
+      throw invalidTimeseriesProviderResult();
+    const pointCount = authoredPoints.length;
+    if (!Number.isSafeInteger(pointCount) || maxPointsPerSeries !== undefined && pointCount > maxPointsPerSeries) {
+      throw invalidTimeseriesProviderResult();
+    }
+    const points = [];
+    for (let index = 0;index < pointCount; index += 1) {
+      points.push(snapshotProviderPoint(authoredPoints[index]));
+    }
+    return { ...series, points };
+  } catch (error) {
+    if (isInvalidTimeseriesProviderResult(error))
+      throw error;
+    throw invalidTimeseriesProviderResult(error);
+  }
+}
+function snapshotProviderPoint(point) {
+  try {
+    const snapshot = structuredClone(point);
+    if (!snapshot || typeof snapshot !== "object")
+      throw invalidTimeseriesProviderResult();
+    return snapshot;
+  } catch (error) {
+    if (isInvalidTimeseriesProviderResult(error))
+      throw error;
+    throw invalidTimeseriesProviderResult(error);
+  }
+}
+function invalidTimeseriesProviderResult(cause) {
+  return createSixbError("internal.unexpected", "[Sixb] Timeseries storage returned data outside the requested series.", cause === undefined ? {} : { cause });
+}
+function isInvalidTimeseriesProviderResult(error) {
+  return error instanceof Error && "code" in error && error.code === "internal.unexpected" && error.message === "[Sixb] Timeseries storage returned data outside the requested series.";
+}
+function telemetryIdentifier(value, field) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`[Sixb] Telemetry history ${field} must be a non-empty string.`);
+  }
+  return value;
+}
+function seriesKey(series) {
+  return JSON.stringify([series.objectTypeId, series.objectId, series.propertyId]);
 }
 // src/objects/context/resolve.ts
 function requireLinkDefinition(objectType, linkId) {
@@ -590,20 +782,23 @@ function createTelemetryChannel(ctx, primaryId) {
       },
       history: async (input = {}) => {
         const timeseries = ctx.storage.timeseries;
+        const objectReader = ctx.objectReader;
         if (!timeseries) {
           throw new RuntimeError("[Sixb] Reading telemetry requires storage.timeseries support.");
         }
+        const from = input.from;
+        const to = input.to;
+        const limit = input.limit;
+        const order = input.order;
         const [result] = await getTelemetryHistoryBatch({
-          projectId: ctx.projectId,
           series: [series],
-          ...input.from !== undefined ? { from: input.from } : {},
-          ...input.to !== undefined ? { to: input.to } : {},
-          ...input.limit !== undefined ? { limitPerSeries: input.limit } : {},
-          ...input.order !== undefined ? { order: input.order } : {}
+          ...from !== undefined ? { from } : {},
+          ...to !== undefined ? { to } : {},
+          ...limit !== undefined ? { limitPerSeries: limit } : {},
+          ...order !== undefined ? { order } : {}
         }, {
           storage: timeseries,
-          runtimeAuthorization: ctx.runtimeAuthorization,
-          authorization: ctx.authorization
+          objectReader
         });
         return (result?.points ?? []).map((point) => ({
           value: point.value,
@@ -620,21 +815,17 @@ function createTelemetryChannel(ctx, primaryId) {
 function createObjectByIdHandle(ctx, primaryId) {
   const objectHandle = {
     get: async () => {
-      assertAuthorized(ctx, { kind: "object.view", objectTypeId: ctx.objectType.id });
-      const row = await ctx.storage.objects.getByPrimaryId({
-        projectId: ctx.projectId,
+      const row = await ctx.objectReader.getByPrimaryId({
         objectTypeId: ctx.objectType.id,
         primaryId
       });
       return row ? row : null;
     },
     listLinks: async (linkToken) => {
-      assertPrivileged(ctx, "listLinks");
       if (linkToken) {
         assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
       }
-      return ctx.storage.objects.listLinks({
-        projectId: ctx.projectId,
+      return ctx.objectReader.listLinks({
         objectTypeId: ctx.objectType.id,
         objectId: primaryId,
         linkId: linkToken?.id
@@ -701,17 +892,11 @@ function createObjectByIdHandle(ctx, primaryId) {
 
 // src/objects/sdk/runtime-query-executor.ts
 function createRuntimeQueryExecutor(params) {
-  const { projectId, ontology, storage, runtimeAuthorization, authorization } = params;
-  const executorOptions = {
-    ontology,
-    storage: storage.objects,
-    runtimeAuthorization,
-    authorization
-  };
+  const { ontology, objectReader } = params;
   return {
     async list(query, options) {
       try {
-        return await executeObjectQuery({ projectId, query, includeTotal: options?.includeTotal }, executorOptions);
+        return await objectReader.executeQuery({ query, includeTotal: options?.includeTotal });
       } catch (error) {
         if (error instanceof ObjectQueryPlanningError) {
           throw addSdkPlanningHints(error);
@@ -720,15 +905,15 @@ function createRuntimeQueryExecutor(params) {
       }
     },
     async count(query) {
-      const result = await countObjects({ projectId, query }, executorOptions);
+      const result = await objectReader.count({ query });
       return result.count;
     },
     async exists(query) {
-      const result = await existsObjects({ projectId, query }, executorOptions);
+      const result = await objectReader.exists({ query });
       return result.exists;
     },
     async facets(query, facets) {
-      const result = await facetObjects({ projectId, query, facets }, executorOptions);
+      const result = await objectReader.facet({ query, facets });
       return result.facets.map((facet) => ({
         propertyId: facet.propertyId,
         buckets: [...facet.buckets]
@@ -753,6 +938,10 @@ function addSdkPlanningHints(error) {
 
 // src/objects/sdk/object-set.ts
 function createObjectSet(params) {
+  assertAuthorizedObjectReaderBinding({
+    reader: params.objectReader,
+    scope: { execution: params.execution, authorization: params.runtimeAuthorization }
+  });
   const { objectType } = params;
   const primaryProp = objectType.properties.find((p) => p.primary);
   if (!primaryProp) {
@@ -767,16 +956,14 @@ function createObjectSet(params) {
     events,
     storage,
     queues,
+    objectReader,
     runtimeAuthorization,
     authorization,
     execution
   } = params;
   const queryExecutor = createRuntimeQueryExecutor({
-    projectId,
     ontology,
-    storage,
-    runtimeAuthorization,
-    authorization
+    objectReader
   });
   const resolvedCtx = {
     projectId,
@@ -786,6 +973,7 @@ function createObjectSet(params) {
     events,
     storage,
     queues,
+    objectReader,
     runtimeAuthorization,
     authorization,
     execution,
@@ -796,9 +984,7 @@ function createObjectSet(params) {
   shareSixbErrorReporter(params, resolvedCtx);
   const objectSet = {
     get: async (id) => {
-      assertAuthorized(resolvedCtx, { kind: "object.view", objectTypeId: objectType.id });
-      const row = await storage.objects.getByPrimaryId({
-        projectId,
+      const row = await objectReader.getByPrimaryId({
         objectTypeId: objectType.id,
         primaryId: id
       });
@@ -814,9 +1000,7 @@ function createObjectSet(params) {
     }),
     byId: (id) => createObjectByIdHandle(resolvedCtx, id),
     list: async (input) => {
-      assertAuthorized(resolvedCtx, { kind: "object.view", objectTypeId: objectType.id });
-      const result = await storage.objects.list({
-        projectId,
+      const result = await objectReader.list({
         objectTypeId: objectType.id,
         primaryIdPrefix: input?.idPrefix,
         primaryIdSuffix: input?.idSuffix,
@@ -952,12 +1136,11 @@ async function removeLink2(runtime, objectTypeId, sourceId, linkId, target) {
 }
 // src/objects/service/list-service.ts
 async function listObjects(runtime, params) {
-  const objectTypeIds = resolveAuthorizedTypeFilter(runtime, params.objectTypeIds);
-  if (runtime.authorization && objectTypeIds !== undefined && objectTypeIds.length === 0) {
+  const objectTypeIds = resolveTypeFilter(runtime, params.objectTypeIds);
+  if (objectTypeIds !== undefined && objectTypeIds.length === 0) {
     return { objects: [], hasMore: false, total: 0 };
   }
-  const result = await runtime.storage.objects.list({
-    projectId: runtime.projectId,
+  const result = await runtime.objectReader.list({
     objectTypeId: objectTypeIds?.length === 1 ? objectTypeIds[0] : objectTypeIds,
     primaryIdPrefix: params.idPrefix,
     primaryIdSuffix: params.idSuffix,
@@ -976,23 +1159,14 @@ async function listObjects(runtime, params) {
     total: result.total
   };
 }
-function resolveAuthorizedTypeFilter(runtime, requested) {
+function resolveTypeFilter(runtime, requested) {
+  const ontology = resolveRuntimeAuthorizationForProject(runtime).type === "delegated" ? getAuthorizedOntologyView(runtime.objectReader) : runtime.ontology;
   if (requested) {
     for (const objectTypeId of requested) {
-      runtime.ontology.resolveObjectType(objectTypeId);
+      ontology.resolveObjectType(objectTypeId);
     }
   }
-  const expanded = requested ? [...new Set(requested.flatMap((id) => [id, ...runtime.ontology.listSubTypes(id)]))] : undefined;
-  if (!runtime.authorization) {
-    return expanded;
-  }
-  if (!expanded) {
-    return [...runtime.authorization.grants["view:object"]];
-  }
-  for (const objectTypeId of expanded) {
-    assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-  }
-  return expanded;
+  return requested ? [...new Set(requested.flatMap((id) => [id, ...ontology.listSubTypes(id)]))] : undefined;
 }
 // src/objects/service/object-service.ts
 async function upsertObject2(runtime, objectTypeId, properties) {
@@ -1006,6 +1180,6 @@ async function appendTelemetry(runtime, objectTypeId, items) {
   const ctx = resolveObjectContext(runtime, objectTypeId);
   await appendTelemetryBatch(ctx, items);
 }
-export { requestAction2 as requestAction, ObjectError, removeLink, upsertLink, upsertLinkBatch, deleteObject, restoreObject, upsertObject, upsertObjectBatch, writeTelemetryBatch, appendTelemetryBatch, getTelemetryHistoryBatch, requireLinkDefinition, resolveObjectContext, resolveLinkContext, createObjectSet, upsertLink2 as upsertLink1, upsertLinkBatch2 as upsertLinkBatch1, removeLink2 as removeLink1, listObjects, upsertObject2 as upsertObject1, upsertObjectBatch2 as upsertObjectBatch1, appendTelemetry, exports_service };
+export { requestAction2 as requestAction, ObjectError, removeLink, upsertLink, upsertLinkBatch, deleteObject, restoreObject, upsertObject, upsertObjectBatch, writeTelemetryBatch, appendTelemetryBatch, getTelemetryHistoryBatch, getLatestTelemetryPoint, requireLinkDefinition, resolveObjectContext, resolveLinkContext, createObjectSet, upsertLink2 as upsertLink1, upsertLinkBatch2 as upsertLinkBatch1, removeLink2 as removeLink1, listObjects, upsertObject2 as upsertObject1, upsertObjectBatch2 as upsertObjectBatch1, appendTelemetry, exports_service };
 
-//# debugId=790282B822F7382564756E2164756E21
+//# debugId=33637F3A5FA7C13764756E2164756E21