@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.6 → 3.5.0-ultramodern.75

package/dist/esm-node/runtime/data-platform/batch/request.mjs

@@ -0,0 +1,46 @@
+import "node:module";
+import { DEFAULT_DATA_BATCH_HEADER } from "../types.mjs";
+function toHeaderRecord(headers) {
+    if (!headers) return {};
+    if (headers instanceof Headers) {
+        const next = {};
+        headers.forEach((value, key)=>{
+            next[key.toLowerCase()] = value;
+        });
+        return next;
+    }
+    if (Array.isArray(headers)) return headers.reduce((acc, [key, value])=>{
+        acc[String(key).toLowerCase()] = String(value);
+        return acc;
+    }, {});
+    return Object.entries(headers).reduce((acc, [key, value])=>{
+        if (void 0 === value) return acc;
+        acc[String(key).toLowerCase()] = Array.isArray(value) ? value.join(', ') : String(value);
+        return acc;
+    }, {});
+}
+function measureTextBytes(value) {
+    if ("u" > typeof TextEncoder) return new TextEncoder().encode(value).length;
+    if ("u" > typeof Buffer) return Buffer.byteLength(value);
+    return value.length;
+}
+function createBatchId() {
+    const now = Date.now().toString(36);
+    const random = Math.random().toString(16).slice(2, 10);
+    return `batch_${now}_${random}`;
+}
+function normalizeMethod(method) {
+    return (method || 'GET').toUpperCase();
+}
+function toRequestBody(initBody) {
+    if ('string' == typeof initBody) return initBody;
+    if ("u" > typeof URLSearchParams && initBody instanceof URLSearchParams) return initBody.toString();
+}
+function shouldBatchRequest(input) {
+    if (input.requestUrl.href === input.batchEndpoint) return false;
+    if ('off' === input.headers[DEFAULT_DATA_BATCH_HEADER]) return false;
+    if (!input.allowedMethods.has(input.method)) return false;
+    if (void 0 !== input.body) return false;
+    return true;
+}
+export { createBatchId, measureTextBytes, normalizeMethod, shouldBatchRequest, toHeaderRecord, toRequestBody };

package/dist/esm-node/runtime/data-platform/batch/response.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { isPlainObject } from "../codec.mjs";
+function isBatchResponseItem(value) {
+    return isPlainObject(value) && 'string' == typeof value.id && 'number' == typeof value.status;
+}
+function isBatchResponsePayload(value) {
+    return isPlainObject(value) && 1 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.receivedAt && Array.isArray(value.items) && value.items.every((item)=>isBatchResponseItem(item));
+}
+async function parseResponseLikeCreateRequest(response) {
+    const contentType = (response.headers.get('content-type') || '').toLowerCase();
+    if (!response.ok) {
+        let data = null;
+        data = contentType.includes('application/json') ? await response.json() : await response.text();
+        response.data = data;
+        throw response;
+    }
+    if (contentType.includes('application/json') || contentType.includes('text/json')) return response.json();
+    if (contentType.includes('text/html') || contentType.includes('text/plain')) return response.text();
+    if (contentType.includes('application/x-www-form-urlencoded') || contentType.includes('multipart/form-data')) return response.formData();
+    if (contentType.includes('application/octet-stream')) return response.arrayBuffer();
+    if (contentType.includes('image/png')) return response;
+    return response.text();
+}
+export { isBatchResponsePayload, parseResponseLikeCreateRequest };

package/dist/esm-node/runtime/data-platform/batch/telemetry.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { trace } from "@opentelemetry/api";
+const DATA_BATCH_TRANSPORT_OTEL_EVENT = 'modernjs.data.batch';
+function createDataBatchTransportTelemetryAttributes(event) {
+    return {
+        'modernjs.data.batch.type': event.type,
+        'modernjs.data.batch.endpoint': event.endpoint,
+        'modernjs.data.batch.degraded': 'fallback' === event.type || 'disable' === event.type,
+        ...event.batchId ? {
+            'modernjs.data.batch.id': event.batchId
+        } : {},
+        ...'number' == typeof event.size ? {
+            'modernjs.data.batch.size': event.size
+        } : {},
+        ...event.reason ? {
+            'modernjs.data.batch.reason': event.reason
+        } : {}
+    };
+}
+function emitDataBatchTransportEvent(onEvent, event) {
+    onEvent?.(event);
+    trace.getActiveSpan()?.addEvent(DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes(event));
+}
+export { DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes, emitDataBatchTransportEvent };

package/dist/esm-node/runtime/data-platform/batch/url.mjs

@@ -0,0 +1,26 @@
+import "node:module";
+import { DEFAULT_DATA_BATCH_ENDPOINT } from "../types.mjs";
+function resolveRuntimeOrigin() {
+    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
+    if ("u" > typeof globalThis && globalThis.location && 'string' == typeof globalThis.location?.origin) return globalThis.location.origin;
+    return 'http://localhost';
+}
+function toAbsoluteUrl(input) {
+    if (input instanceof URL) return input;
+    if ("u" > typeof Request && input instanceof Request) return new URL(input.url);
+    const value = String(input);
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, resolveRuntimeOrigin());
+    }
+}
+function normalizeBatchEndpoint(requestUrl, endpoint) {
+    const value = endpoint || DEFAULT_DATA_BATCH_ENDPOINT;
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, requestUrl.origin);
+    }
+}
+export { normalizeBatchEndpoint, resolveRuntimeOrigin, toAbsoluteUrl };

package/dist/esm-node/runtime/data-platform/batch-transport.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+import { createBatchTransportQueue } from "./batch/queue.mjs";
+function createDataBatchTransport(options = {}) {
+    const fallbackFetch = 'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
+    const baseFetch = options.fetch || fallbackFetch;
+    if (!baseFetch) throw new Error('createDataBatchTransport requires a fetch implementation');
+    return createBatchTransportQueue({
+        options,
+        baseFetch
+    });
+}
+export { DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes, emitDataBatchTransportEvent } from "./batch/telemetry.mjs";
+export { createDataBatchTransport };

package/dist/esm-node/runtime/data-platform/codec.mjs

@@ -0,0 +1,91 @@
+import "node:module";
+function isPlainObject(value) {
+    if ('object' != typeof value || null === value || Array.isArray(value)) return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || null === proto;
+}
+function canonicalize(value) {
+    if (Array.isArray(value)) return value.map((item)=>canonicalize(item));
+    if (isPlainObject(value)) return Object.keys(value).sort().reduce((acc, key)=>{
+        acc[key] = canonicalize(value[key]);
+        return acc;
+    }, {});
+    return value;
+}
+function stableStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function encodeRequestEnvelopeHeader(envelope) {
+    return encodeURIComponent(stableStringify(envelope));
+}
+function isRequestEnvelopeShape(value) {
+    if (!isPlainObject(value)) return false;
+    return 1 === value.protocolVersion && 'string' == typeof value.operationId && 'string' == typeof value.appNamespace && 'string' == typeof value.origin && 'string' == typeof value.scopeKey && 'string' == typeof value.inputHash && 'number' == typeof value.timestamp;
+}
+function decodeRequestEnvelopeHeader(value) {
+    try {
+        const decoded = decodeURIComponent(value);
+        const parsed = JSON.parse(decoded);
+        if (!isRequestEnvelopeShape(parsed)) return null;
+        return parsed;
+    } catch  {
+        return null;
+    }
+}
+function hashString(value) {
+    let hash = 0x811c9dc5;
+    for(let index = 0; index < value.length; index++){
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function sanitizeSegment(segment) {
+    const normalized = segment.trim().replace(/[^a-zA-Z0-9_-]+/g, '_');
+    return normalized.length > 0 ? normalized : 'unknown';
+}
+function normalizeOrigin(origin) {
+    const normalized = origin.trim();
+    try {
+        const url = new URL(normalized);
+        return `${url.protocol}//${url.host}`.toLowerCase();
+    } catch  {
+        return normalized.toLowerCase();
+    }
+}
+function normalizeOperationDescriptor(input) {
+    return {
+        appNamespace: sanitizeSegment(input.appNamespace),
+        apiId: sanitizeSegment(input.apiId),
+        group: sanitizeSegment(input.group),
+        endpoint: sanitizeSegment(input.endpoint),
+        schemaHash: input.schemaHash || null,
+        version: input.version ?? 1
+    };
+}
+function createOperationId(input) {
+    const descriptor = normalizeOperationDescriptor(input);
+    const readable = `${descriptor.appNamespace}.${descriptor.apiId}.${descriptor.group}.${descriptor.endpoint}.v${String(descriptor.version)}`;
+    return `${readable}:${hashString(stableStringify(descriptor))}`;
+}
+function buildScopeKey(scope) {
+    const canonical = {
+        appNamespace: sanitizeSegment(scope.appNamespace),
+        origin: normalizeOrigin(scope.origin),
+        tenantId: scope.tenantId ?? null,
+        userId: scope.userId ?? null,
+        sessionId: scope.sessionId ?? null
+    };
+    return `${canonical.appNamespace}:${hashString(stableStringify(canonical))}`;
+}
+function buildQueryKey(input) {
+    const canonical = {
+        operationId: input.operationId,
+        scopeKey: input.scopeKey,
+        requestMode: input.requestMode ?? 'cache-first',
+        requestInput: input.requestInput ?? null,
+        selectionPlan: input.selectionPlan ?? null
+    };
+    return `${input.operationId}:${hashString(stableStringify(canonical))}`;
+}
+export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, hashString, isPlainObject, normalizeOrigin, sanitizeSegment, stableStringify };