@bleedingdev/modern-js-utils 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

package/dist/esm-node/universal/backend-federation-contract/index.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+export { createUltramodernBuildArtifact, isUltramodernBuildArtifact, stampUltramodernBuildArtifactSourceRevision, validateUltramodernBuildArtifact } from "./build-artifact.mjs";
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_IDENTITY_FIELDS, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_FILE, ULTRAMODERN_BUILD_MODULE_PATH } from "./constants.mjs";
+export { deliveryUnitContractBlock, deliveryUnitIdentityFieldValue, toDeliveryUnitIdentity, validateDeliveryUnitContractBlock, validateDeliveryUnitIdentity, validateDeliveryUnitRecord } from "./delivery-unit.mjs";
+export { backendFederationExposeNames, backendFederationMetadata, backendFederationVersionBoundary, toBackendFederationExposeNames, validateBackendFederationManifest, validateBackendFederationMetadata } from "./metadata.mjs";
+export { formatBackendFederationValidationErrors, nonEmptyString } from "./validation-core.mjs";

package/dist/esm-node/universal/backend-federation-contract/metadata.mjs

@@ -0,0 +1,81 @@
+import "node:module";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, DELIVERY_UNIT_IDENTITY_FIELDS, DELIVERY_UNIT_SCHEMA_VERSION } from "./constants.mjs";
+import { deliveryUnitIdentityFieldValue, validateDeliveryUnitBoundaryIdentity, validateDeliveryUnitContractBlock } from "./delivery-unit.mjs";
+import { addError, isRecord, nonEmptyString, recordField, validateVersionField, validationResult } from "./validation-core.mjs";
+const toBackendFederationExposeNames = (value)=>{
+    const names = [];
+    if (Array.isArray(value)) for (const expose of value){
+        const name = nonEmptyString(expose) ?? (isRecord(expose) ? nonEmptyString(expose.name) : void 0);
+        if (name) names.push(name);
+    }
+    else if (isRecord(value)) names.push(...Object.keys(value).filter((name)=>name.length > 0));
+    return Array.from(new Set(names));
+};
+const backendFederationExposeNames = (value)=>{
+    if (!isRecord(value)) return [];
+    const exposes = toBackendFederationExposeNames(value.exposes);
+    const expose = nonEmptyString(value.expose);
+    return Array.from(new Set([
+        ...exposes,
+        ...expose ? [
+            expose
+        ] : []
+    ]));
+};
+const backendFederationMetadata = (value)=>isRecord(value) ? recordField(value, 'backendFederation') : void 0;
+const backendFederationVersionBoundary = (value)=>recordField(backendFederationMetadata(value), 'versionBoundary');
+const validateBackendFederationMetadata = (value, options = {})=>{
+    const path = options.path ?? 'backendFederation';
+    const errors = [];
+    if (!isRecord(value)) {
+        addError(errors, path, 'must be an object.');
+        return validationResult(errors);
+    }
+    if (options.requireEffectRuntime && 'effect' !== value.runtimeFramework) addError(errors, `${path}.runtimeFramework`, 'must be "effect".');
+    if (options.requireEffectRuntime && true !== value.strictEffectApproach) addError(errors, `${path}.strictEffectApproach`, 'must be true.');
+    validateVersionField(errors, value, 'contractVersion', options.expectedContractVersion ?? BACKEND_FEDERATION_CONTRACT_VERSION, path, options.requireVersionFields ?? false);
+    validateVersionField(errors, value, 'nodeAdapterVersion', options.expectedNodeAdapterVersion ?? BACKEND_FEDERATION_NODE_ADAPTER_VERSION, path, options.requireVersionFields ?? false);
+    if (options.requireEffectExpose && !backendFederationExposeNames(value).includes(BACKEND_FEDERATION_EFFECT_EXPOSE)) addError(errors, `${path}.expose`, `must include "${BACKEND_FEDERATION_EFFECT_EXPOSE}".`);
+    if (options.validateDeliveryUnit ?? true) {
+        const deliveryUnit = recordField(value, 'deliveryUnit');
+        if (deliveryUnit) errors.push(...validateDeliveryUnitContractBlock(deliveryUnit, {
+            path: `${path}.deliveryUnit`
+        }).errors);
+        const versionBoundary = recordField(value, 'versionBoundary');
+        const versionBoundaryDeliveryUnit = recordField(versionBoundary, 'deliveryUnit');
+        if (versionBoundaryDeliveryUnit) errors.push(...validateDeliveryUnitBoundaryIdentity(versionBoundaryDeliveryUnit, `${path}.versionBoundary.deliveryUnit`));
+        if (deliveryUnit && versionBoundaryDeliveryUnit) for (const field of DELIVERY_UNIT_IDENTITY_FIELDS){
+            const deliveryUnitValue = deliveryUnitIdentityFieldValue(deliveryUnit, field);
+            const versionBoundaryDeliveryUnitValue = deliveryUnitIdentityFieldValue(versionBoundaryDeliveryUnit, field);
+            if (deliveryUnitValue && versionBoundaryDeliveryUnitValue && deliveryUnitValue !== versionBoundaryDeliveryUnitValue) addError(errors, `${path}.versionBoundary.deliveryUnit.${field}`, `must match ${path}.deliveryUnit.${field}.`);
+        }
+    }
+    return validationResult(errors);
+};
+const validateBackendFederationManifest = (value, options = {})=>{
+    const path = options.path ?? 'manifest';
+    const errors = [];
+    if (!isRecord(value)) {
+        addError(errors, path, 'must be an object.');
+        return validationResult(errors);
+    }
+    if (void 0 !== value.schemaVersion && value.schemaVersion !== DELIVERY_UNIT_SCHEMA_VERSION) addError(errors, `${path}.schemaVersion`, `must be ${DELIVERY_UNIT_SCHEMA_VERSION}.`);
+    const metadata = backendFederationMetadata(value);
+    if (metadata) errors.push(...validateBackendFederationMetadata(metadata, {
+        ...options,
+        path: `${path}.backendFederation`,
+        requireEffectExpose: false
+    }).errors);
+    else if (options.requireBackendFederation ?? true) addError(errors, `${path}.backendFederation`, 'must be an object.');
+    if (options.requireEffectExpose) {
+        const topLevelExposeNames = toBackendFederationExposeNames(value.exposes);
+        const metadataExposeNames = backendFederationExposeNames(metadata);
+        const exposeNames = new Set([
+            ...topLevelExposeNames,
+            ...metadataExposeNames
+        ]);
+        if (!exposeNames.has(BACKEND_FEDERATION_EFFECT_EXPOSE)) addError(errors, `${path}.exposes`, `must include "${BACKEND_FEDERATION_EFFECT_EXPOSE}".`);
+    }
+    return validationResult(errors);
+};
+export { backendFederationExposeNames, backendFederationMetadata, backendFederationVersionBoundary, toBackendFederationExposeNames, validateBackendFederationManifest, validateBackendFederationMetadata };

package/dist/esm-node/universal/backend-federation-contract/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/universal/backend-federation-contract/validation-core.mjs

@@ -0,0 +1,30 @@
+import "node:module";
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const nonEmptyString = (value)=>'string' == typeof value && value.trim().length > 0 ? value : void 0;
+const validationResult = (errors)=>({
+        ok: 0 === errors.length,
+        errors
+    });
+const addError = (errors, path, message)=>{
+    errors.push({
+        path,
+        message
+    });
+};
+const recordField = (value, field)=>{
+    const fieldValue = value?.[field];
+    return isRecord(fieldValue) ? fieldValue : void 0;
+};
+const formatBackendFederationValidationErrors = (errors)=>errors.map((error)=>`${error.path}: ${error.message}`).join('; ');
+const validateVersionField = (errors, record, field, expected, path, required)=>{
+    const compatibility = recordField(record, 'compatibility');
+    const executionSurfaces = recordField(record, 'executionSurfaces');
+    const nodeSurface = recordField(executionSurfaces, 'node');
+    const actual = nonEmptyString(record[field]) ?? nonEmptyString(compatibility?.[field]) ?? ('nodeAdapterVersion' === field ? nonEmptyString(nodeSurface?.adapterVersion) : void 0);
+    if (!actual) {
+        if (required) addError(errors, `${path}.${field}`, 'must be a non-empty string.');
+        return;
+    }
+    if (false !== expected && actual !== expected) addError(errors, `${path}.${field}`, `must be "${expected}".`);
+};
+export { addError, formatBackendFederationValidationErrors, isRecord, nonEmptyString, recordField, validateVersionField, validationResult };

package/dist/esm-node/universal/index.mjs

@@ -1,2 +1,3 @@
 import "node:module";
+export * from "./backend-federation-contract/index.mjs";
 export { cutNameByHyphen } from "./path.mjs";

package/dist/types/import.d.ts

@@ -1,5 +1,5 @@
 declare const lazy: (moduleName: string, getRequireFn: () => (id: string) => unknown) => any;
 export { lazy as lazyImport };
 export declare const Import: {
-    lazy: (moduleName: string, getRequireFn: () => (id: string) => unknown) => any;
+    lazy: typeof lazy;
 };

package/dist/types/universal/backend-federation-contract/build-artifact.d.ts

@@ -0,0 +1,5 @@
+import type { BackendFederationContractValidationResult, DeliveryUnitRecord, UltramodernBuildArtifact } from './types';
+export declare const createUltramodernBuildArtifact: (record: DeliveryUnitRecord) => UltramodernBuildArtifact;
+export declare const validateUltramodernBuildArtifact: (value: unknown, path?: string) => BackendFederationContractValidationResult;
+export declare const isUltramodernBuildArtifact: (value: unknown) => value is UltramodernBuildArtifact;
+export declare const stampUltramodernBuildArtifactSourceRevision: (artifact: UltramodernBuildArtifact, sourceRevision: string) => UltramodernBuildArtifact;

package/dist/types/universal/backend-federation-contract/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const BACKEND_FEDERATION_EFFECT_EXPOSE = "./effect-api";
+export declare const BACKEND_FEDERATION_MANIFEST_FILE = "backend-mf-manifest.json";
+export declare const BACKEND_FEDERATION_REMOTE_ENTRY_FILE = "backendRemoteEntry.mjs";
+export declare const BACKEND_FEDERATION_CONTRACT_VERSION = "microvertical-server-effect-v1";
+export declare const BACKEND_FEDERATION_NODE_ADAPTER_VERSION = "backend-mf-effect-v1";
+export declare const DELIVERY_UNIT_SCHEMA_VERSION = 1;
+export declare const DELIVERY_UNIT_KIND = "microvertical-delivery-unit";
+export declare const DELIVERY_UNIT_DEPLOY_PROFILE = "cloudflare-ssr-mf-effect-v1";
+export declare const DELIVERY_UNIT_IDENTITY_FIELDS: readonly ['unitId', 'buildMarker', 'sourceRevision'];
+export type DeliveryUnitIdentityField = (typeof DELIVERY_UNIT_IDENTITY_FIELDS)[number];
+export declare const ULTRAMODERN_BUILD_ARTIFACT_FILE = "ultramodern-build.json";
+export declare const ULTRAMODERN_BUILD_ARTIFACT_PATH = "shared/ultramodern-build.json";
+export declare const ULTRAMODERN_BUILD_MODULE_FILE = "ultramodern-build.ts";
+export declare const ULTRAMODERN_BUILD_MODULE_PATH = "shared/ultramodern-build.ts";

package/dist/types/universal/backend-federation-contract/delivery-unit.d.ts

@@ -0,0 +1,9 @@
+import type { DeliveryUnitIdentityField } from './constants';
+import type { BackendFederationContractValidationError, BackendFederationContractValidationResult, DeliveryUnitContractBlock, DeliveryUnitIdentity, DeliveryUnitRecord, ValidateDeliveryUnitIdentityOptions } from './types';
+export declare const deliveryUnitIdentityFieldValue: (value: unknown, field: DeliveryUnitIdentityField, options?: Pick<ValidateDeliveryUnitIdentityOptions, 'allowBuildAlias'>) => string | undefined;
+export declare const validateDeliveryUnitIdentity: (value: unknown, options?: ValidateDeliveryUnitIdentityOptions) => BackendFederationContractValidationResult;
+export declare const validateDeliveryUnitContractBlock: (value: unknown, options?: ValidateDeliveryUnitIdentityOptions) => BackendFederationContractValidationResult;
+export declare const validateDeliveryUnitRecord: (value: unknown, options?: ValidateDeliveryUnitIdentityOptions) => BackendFederationContractValidationResult;
+export declare const validateDeliveryUnitBoundaryIdentity: (value: unknown, path: string) => BackendFederationContractValidationError[];
+export declare const deliveryUnitContractBlock: (record: DeliveryUnitRecord) => DeliveryUnitContractBlock;
+export declare const toDeliveryUnitIdentity: (value: unknown) => DeliveryUnitIdentity | undefined;

package/dist/types/universal/backend-federation-contract/index.d.ts

@@ -0,0 +1,7 @@
+export { createUltramodernBuildArtifact, isUltramodernBuildArtifact, stampUltramodernBuildArtifactSourceRevision, validateUltramodernBuildArtifact, } from './build-artifact';
+export type { DeliveryUnitIdentityField } from './constants';
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_IDENTITY_FIELDS, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_FILE, ULTRAMODERN_BUILD_MODULE_PATH, } from './constants';
+export { deliveryUnitContractBlock, deliveryUnitIdentityFieldValue, toDeliveryUnitIdentity, validateDeliveryUnitContractBlock, validateDeliveryUnitIdentity, validateDeliveryUnitRecord, } from './delivery-unit';
+export { backendFederationExposeNames, backendFederationMetadata, backendFederationVersionBoundary, toBackendFederationExposeNames, validateBackendFederationManifest, validateBackendFederationMetadata, } from './metadata';
+export type { BackendFederationContractValidationError, BackendFederationContractValidationResult, DeliveryUnitContractBlock, DeliveryUnitIdentity, DeliveryUnitRecord, UltramodernBuildArtifact, UltramodernBuildDeliveryUnit, UltramodernBuildSurface, ValidateBackendFederationManifestOptions, ValidateBackendFederationMetadataOptions, ValidateDeliveryUnitIdentityOptions, } from './types';
+export { formatBackendFederationValidationErrors, nonEmptyString, } from './validation-core';

package/dist/types/universal/backend-federation-contract/metadata.d.ts

@@ -0,0 +1,7 @@
+import type { BackendFederationContractValidationResult, ValidateBackendFederationManifestOptions, ValidateBackendFederationMetadataOptions } from './types';
+export declare const toBackendFederationExposeNames: (value: unknown) => string[];
+export declare const backendFederationExposeNames: (value: unknown) => string[];
+export declare const backendFederationMetadata: (value: unknown) => Record<string, unknown> | undefined;
+export declare const backendFederationVersionBoundary: (value: unknown) => Record<string, unknown> | undefined;
+export declare const validateBackendFederationMetadata: (value: unknown, options?: ValidateBackendFederationMetadataOptions) => BackendFederationContractValidationResult;
+export declare const validateBackendFederationManifest: (value: unknown, options?: ValidateBackendFederationManifestOptions) => BackendFederationContractValidationResult;

package/dist/types/universal/backend-federation-contract/types.d.ts

@@ -0,0 +1,60 @@
+import type { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION } from './constants';
+export type DeliveryUnitIdentity = {
+    unitId: string;
+    buildMarker: string;
+    sourceRevision: string;
+};
+export type DeliveryUnitRecord = DeliveryUnitIdentity & {
+    schemaVersion: typeof DELIVERY_UNIT_SCHEMA_VERSION;
+    kind: typeof DELIVERY_UNIT_KIND;
+    appId: string;
+    packageName: string;
+    version: string;
+    deployProfile: typeof DELIVERY_UNIT_DEPLOY_PROFILE;
+};
+export type DeliveryUnitContractBlock = Omit<DeliveryUnitRecord, 'appId' | 'deployProfile'>;
+export type UltramodernBuildDeliveryUnit = DeliveryUnitRecord & {
+    build: string;
+};
+export type UltramodernBuildSurface = (UltramodernBuildDeliveryUnit & {
+    surface: 'ui';
+}) | (UltramodernBuildDeliveryUnit & {
+    surface: 'api';
+});
+export type UltramodernBuildArtifact = {
+    schemaVersion: typeof DELIVERY_UNIT_SCHEMA_VERSION;
+    kind: 'ultramodern-build-artifact';
+    deliveryUnit: UltramodernBuildDeliveryUnit;
+    surfaces: {
+        ui: UltramodernBuildDeliveryUnit & {
+            surface: 'ui';
+        };
+        api: UltramodernBuildDeliveryUnit & {
+            surface: 'api';
+        };
+    };
+};
+export type BackendFederationContractValidationError = {
+    path: string;
+    message: string;
+};
+export type BackendFederationContractValidationResult = {
+    ok: boolean;
+    errors: BackendFederationContractValidationError[];
+};
+export type ValidateDeliveryUnitIdentityOptions = {
+    path?: string;
+    allowBuildAlias?: boolean;
+};
+export type ValidateBackendFederationMetadataOptions = {
+    path?: string;
+    expectedContractVersion?: string | false;
+    expectedNodeAdapterVersion?: string | false;
+    validateDeliveryUnit?: boolean;
+    requireEffectExpose?: boolean;
+    requireEffectRuntime?: boolean;
+    requireVersionFields?: boolean;
+};
+export type ValidateBackendFederationManifestOptions = ValidateBackendFederationMetadataOptions & {
+    requireBackendFederation?: boolean;
+};

package/dist/types/universal/backend-federation-contract/validation-core.d.ts

@@ -0,0 +1,8 @@
+import type { BackendFederationContractValidationError, BackendFederationContractValidationResult } from './types';
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const nonEmptyString: (value: unknown) => string | undefined;
+export declare const validationResult: (errors: BackendFederationContractValidationError[]) => BackendFederationContractValidationResult;
+export declare const addError: (errors: BackendFederationContractValidationError[], path: string, message: string) => void;
+export declare const recordField: (value: Record<string, unknown> | undefined, field: string) => Record<string, unknown> | undefined;
+export declare const formatBackendFederationValidationErrors: (errors: BackendFederationContractValidationError[]) => string;
+export declare const validateVersionField: (errors: BackendFederationContractValidationError[], record: Record<string, unknown>, field: 'contractVersion' | 'nodeAdapterVersion', expected: string | false, path: string, required: boolean) => void;

package/dist/types/universal/index.d.ts

@@ -1 +1,2 @@
+export * from './backend-federation-contract';
 export { cutNameByHyphen } from './path';

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.4",
+  "version": "3.5.0-ultramodern.40",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -181,18 +181,18 @@
   },
   "dependencies": {
     "@swc/helpers": "^0.5.23",
-    "caniuse-lite": "^1.0.30001799",
+    "caniuse-lite": "^1.0.30001803",
     "import-meta-resolve": "^4.2.0",
     "lodash": "^4.18.1",
     "lodash-es": "^4.18.1",
     "rslog": "^2.1.3"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.1",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260628.1",
+    "@rslib/core": "0.23.2",
+    "@types/node": "^26.1.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "happy-dom": "^20.10.6",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.4",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.40",
     "@scripts/rstest-config": "2.66.0"
   },
   "peerDependencies": {