@azure-net/kit 0.8.1 → 0.8.7

package/dist/core/delivery/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../../edges/index.js';
+export * from './injectableDependencies/index.js';
+export * from './serverAction/index.js';

package/dist/core/delivery/index.js

@@ -0,0 +1,3 @@
+export * from '../../edges/index.js';
+export * from './injectableDependencies/index.js';
+export * from './serverAction/index.js';

package/dist/core/{provider/dependencies → delivery/injectableDependencies}/ErrorHandler.d.ts

@@ -1,4 +1,4 @@
-import { BaseRequest, type RequestErrors } from '../../request/index.js';
+import { BaseRequest, type RequestErrors } from '../../shared/request/index.js';
 import { HttpServiceError } from '../../infra/httpService/index.js';
 export type AppErrorType = 'http' | 'request' | 'app' | 'abort';
 export interface AppError<T = unknown, D = never> {

package/dist/core/{provider/dependencies → delivery/injectableDependencies}/ErrorHandler.js

@@ -1,4 +1,4 @@
-import { BaseRequest } from '../../request/index.js';
+import { BaseRequest } from '../../shared/request/index.js';
 import { HttpServiceError } from '../../infra/httpService/index.js';
 export const parseHttpError = (error) => {
     return {

package/dist/core/delivery/schema/Schema.d.ts

@@ -0,0 +1,33 @@
+type DeepKeys<T> = T extends object ? {
+    [K in keyof T & string]: T[K] extends object ? K | `${K}.${DeepKeys<T[K]>}` : K;
+}[keyof T & string] : never;
+export type ValidationParams<T = unknown, V = unknown, K = string> = {
+    val: V;
+    listValues?: Partial<T>;
+    key?: K;
+};
+export type ValidationMessage = string | {
+    key: string;
+    vars?: Record<string, unknown>;
+};
+export interface ValidationErrorsMap {
+    [key: string]: ValidationMessage | ValidationErrorsMap;
+}
+export type ValidationResult = ValidationMessage | ValidationErrorsMap | ValidationErrorsMap[] | undefined;
+export type ValidationRuleResult<CurrentValue, ListValues = unknown, CurrentKey = string> = (params: ValidationParams<CurrentValue, ListValues, CurrentKey>) => ValidationResult;
+type ValidationErrors<T> = T extends ReadonlyArray<infer U> ? ValidationErrors<U>[] : T extends object ? {
+    [K in keyof T]?: ValidationErrors<T[K]>;
+} : ValidationMessage;
+export type RequestErrors<Dict> = Partial<ValidationErrors<Dict>>;
+export type RequestRules<D> = Partial<Record<DeepKeys<D>, ValidationRuleResult<D>[]>>;
+export declare const createSchemaFactory: <Rules>(rulesList: Rules) => <IncomingData, DataAfterTransform = IncomingData>(params: {
+    schema: (rules: Rules) => RequestRules<IncomingData>;
+    transform: (data: IncomingData) => DataAfterTransform;
+}) => {
+    from: (data: IncomingData) => void;
+    json: () => DataAfterTransform;
+    formData: () => FormData;
+    validate: () => undefined;
+    readonly errors: Partial<ValidationErrors<IncomingData>>;
+};
+export {};

package/dist/core/delivery/schema/Schema.js

@@ -0,0 +1,78 @@
+import { FormDataUtil } from 'azure-net-tools';
+export const createSchemaFactory = (rulesList) => {
+    return (params) => {
+        let schemaData;
+        let _errors = {};
+        let _isValid = true;
+        const { schema, transform = (data) => data } = params;
+        const definedSchema = schema(rulesList);
+        const getByPath = (path) => {
+            return path.split('.').reduce((o, k) => (o && typeof o === 'object' ? o[k] : undefined), schemaData);
+        };
+        const setByPath = (obj, path, value) => {
+            const keys = path.split('.');
+            let current = obj;
+            for (let i = 0; i < keys.length - 1; i++) {
+                const k = keys[i];
+                if (!(k in current) || typeof current[k] !== 'object') {
+                    current[k] = {};
+                }
+                current = current[k];
+            }
+            current[keys[(keys.length - 1)]] = value;
+        };
+        const prepare = (dataToPrepare) => {
+            if (dataToPrepare instanceof FormData) {
+                return FormDataUtil.toObject(dataToPrepare);
+            }
+            return dataToPrepare;
+        };
+        const validate = () => {
+            _isValid = true;
+            _errors = {};
+            if (typeof schemaData !== 'object') {
+                throw Error('Data to validate is not an object');
+            }
+            for (const key in definedSchema) {
+                const fieldRules = definedSchema[key] ?? [];
+                const value = getByPath(key);
+                for (const rule of fieldRules) {
+                    const failMessage = rule({
+                        val: value,
+                        listValues: schemaData,
+                        key: key
+                    });
+                    if (failMessage) {
+                        setByPath(_errors, key, failMessage);
+                        _isValid = false;
+                        break;
+                    }
+                }
+            }
+            if (!_isValid) {
+                throw this;
+            }
+            return this;
+        };
+        const from = (data) => {
+            schemaData = prepare(data);
+        };
+        const formData = () => {
+            validate();
+            return FormDataUtil.fromObject(transform(schemaData));
+        };
+        const json = () => {
+            validate();
+            return transform(schemaData);
+        };
+        return {
+            from,
+            json,
+            formData,
+            validate,
+            get errors() {
+                return _errors;
+            }
+        };
+    };
+};

package/dist/core/delivery/schema/index.d.ts

@@ -0,0 +1 @@
+export * from './Schema.js';

package/dist/core/delivery/schema/index.js

@@ -0,0 +1 @@
+export * from './Schema.js';

package/dist/core/delivery/schema/rules/Rules.d.ts

@@ -0,0 +1,59 @@
+import type { BaseValidationMessages } from './messages/types.js';
+import type { ValidationParams, ValidationRuleResult } from '../index.js';
+import { type CountryCode } from 'libphonenumber-js';
+export type ValidationRuleParams<T extends keyof BaseValidationMessages, D = object> = D & {
+    message?: BaseValidationMessages[T];
+};
+export type LengthParams = {
+    length?: {
+        min?: number;
+        max?: number;
+    };
+};
+export type RangeParams = {
+    range?: {
+        min?: number;
+        max?: number;
+    };
+};
+type ArrayItemRules<Context> = ValidationRuleResult<Context>[] | Record<string, ValidationRuleResult<Context>[]>;
+type ArrayParams<Context> = LengthParams & {
+    schema?: ArrayItemRules<Context>;
+};
+export declare const createRules: <M extends BaseValidationMessages>(validationMessages: M) => {
+    string: <T = unknown, D = unknown>(params?: ValidationRuleParams<"string", LengthParams>) => ValidationRuleResult<T, D>;
+    number: <T = unknown, D_1 = unknown>(params?: ValidationRuleParams<"number", RangeParams>) => ValidationRuleResult<T, D_1>;
+    required: <T = unknown, D_2 = unknown, J = unknown>(params?: ValidationRuleParams<"required", {
+        byCondition?: (params: ValidationParams<T, D_2, J>) => boolean;
+    }>) => ValidationRuleResult<T, D_2, J>;
+    password: <T = unknown, D_3 = unknown>(params?: ValidationRuleParams<"password", {
+        length?: number;
+        specialChars?: boolean | number;
+        numbers?: boolean | number;
+        lowerUpperCasePattern?: boolean;
+    }>) => ValidationRuleResult<T, D_3>;
+    notSameAs: <T = unknown, D_4 = unknown>(params: ValidationRuleParams<"sameAs", {
+        key: keyof T | string;
+    }>) => ValidationRuleResult<T, D_4>;
+    sameAs: <T = unknown, D_5 = unknown>(params: ValidationRuleParams<"sameAs", {
+        key: keyof T | string;
+    }>) => ValidationRuleResult<T, D_5>;
+    array: <T = unknown>(params?: ValidationRuleParams<"array", ArrayParams<T>>) => ValidationRuleResult<T>;
+    boolean: <T = unknown, D_6 = unknown>(params?: ValidationRuleParams<"boolean", {
+        expected?: boolean;
+    }>) => ValidationRuleResult<T, D_6>;
+    email: <T = unknown, D_7 = unknown>(params?: ValidationRuleParams<"email">) => ValidationRuleResult<T, D_7>;
+    finite: <T = unknown, D_8 = unknown>(params?: ValidationRuleParams<"finite", RangeParams & {
+        maxDigitsAfterDot?: number;
+    }>) => ValidationRuleResult<T, D_8>;
+    lettersOnly: <T = unknown, D_9 = unknown>(params?: ValidationRuleParams<"lettersOnly", {
+        whiteSpaces?: boolean;
+    }>) => ValidationRuleResult<T, D_9>;
+    phone: <T = unknown, D_10 = unknown>(params?: ValidationRuleParams<"phone", {
+        country: CountryCode;
+    }>) => ValidationRuleResult<T, D_10>;
+    allowedOnly: <T = unknown, D_11 = unknown>(params?: ValidationRuleParams<"allowedOnly", {
+        allowed?: unknown[];
+    }>) => ValidationRuleResult<T, D_11>;
+};
+export {};

package/dist/core/delivery/schema/rules/Rules.js

@@ -0,0 +1,285 @@
+import { isValidNumber } from 'libphonenumber-js';
+export const createRules = (validationMessages) => {
+    const checkVal = (val) => {
+        return val !== undefined && val !== null;
+    };
+    const string = (params) => {
+        const { message, length } = { ...params, message: { ...validationMessages.string, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                if (typeof val !== 'string') {
+                    return message.base();
+                }
+                switch (true) {
+                    case length && checkVal(length.min) && val.length < length.min:
+                        return message.min(length.min);
+                    case length && checkVal(length.max) && val.length > length.max:
+                        return message.max(length.max);
+                    default:
+                        return undefined;
+                }
+            }
+            return undefined;
+        };
+    };
+    const number = (params) => {
+        const { message, range } = { ...params, message: { ...validationMessages.number, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const numberVal = Number(val);
+                if (!Number.isInteger(numberVal) || Number.isNaN(numberVal)) {
+                    return message.base();
+                }
+                switch (true) {
+                    case range && checkVal(range?.min) && numberVal < range.min:
+                        return message.min(range.min);
+                    case range && checkVal(range?.max) && numberVal > range.max:
+                        return message.max(range.max);
+                    default:
+                        return undefined;
+                }
+            }
+            return undefined;
+        };
+    };
+    const finite = (params) => {
+        const { message, maxDigitsAfterDot, range } = { ...params, message: { ...validationMessages.finite, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const numVal = Number(val);
+                if (!Number.isFinite(numVal) || String(val)[0] === '.') {
+                    return message.base();
+                }
+                if (typeof maxDigitsAfterDot === 'number') {
+                    const digitsAfterDot = val.toString().split('.')[1]?.length ?? 0;
+                    if (digitsAfterDot > maxDigitsAfterDot) {
+                        return message.maxDigitsAfterDot(maxDigitsAfterDot);
+                    }
+                }
+                if (range?.min !== undefined && numVal < range.min)
+                    return message.min(range.min);
+                if (range?.max !== undefined && numVal > range.max)
+                    return message.max(range.max);
+                return undefined;
+            }
+            return undefined;
+        };
+    };
+    const boolean = (params) => {
+        const { message, expected } = { ...params, message: { ...validationMessages.boolean, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                if (typeof val !== 'boolean')
+                    return message.base();
+                if (expected !== undefined && val !== expected)
+                    return message.expected(String(expected));
+                return undefined;
+            }
+            return undefined;
+        };
+    };
+    const array = (params) => {
+        const { message, length = {}, schema } = { ...params, message: { ...validationMessages.array, ...params?.message } };
+        return ({ val, listValues, key }) => {
+            if (checkVal(val)) {
+                if (!Array.isArray(val))
+                    return message.base();
+                if (length.min && val.length < length.min)
+                    return message.min(length.min);
+                if (length.max && val.length > length.max)
+                    return message.max(length.max);
+                if (schema) {
+                    const nestedErrors = [];
+                    for (let index = 0; index < val.length; index++) {
+                        const element = val[index];
+                        const itemErrors = {};
+                        if (Array.isArray(schema)) {
+                            for (const rule of schema) {
+                                const fail = rule({
+                                    val: element,
+                                    listValues,
+                                    key: `${key}[${index}]`
+                                });
+                                if (fail) {
+                                    itemErrors['_error'] = fail;
+                                    break;
+                                }
+                            }
+                        }
+                        else if (typeof schema === 'object' && schema !== null) {
+                            if (typeof element !== 'object' || element === null) {
+                                itemErrors['_error'] = message.base();
+                            }
+                            else {
+                                for (const fieldKey in schema) {
+                                    const fieldRules = schema[fieldKey] ?? [];
+                                    const fieldValue = element?.[fieldKey];
+                                    for (const rule of fieldRules) {
+                                        const fail = rule({
+                                            val: fieldValue,
+                                            listValues,
+                                            key: `${key}[${index}].${fieldKey}`
+                                        });
+                                        if (fail) {
+                                            itemErrors[fieldKey] = fail;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        nestedErrors[index] = itemErrors;
+                    }
+                    if (nestedErrors.some((e) => Object.keys(e).length > 0)) {
+                        return nestedErrors;
+                    }
+                }
+            }
+            return undefined;
+        };
+    };
+    const phone = (params) => {
+        const { message, country = 'RU' } = { ...params, message: params?.message ?? validationMessages.phone };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                return isValidNumber(String(val), country) ? undefined : message();
+            }
+            return undefined;
+        };
+    };
+    const email = (params) => {
+        const { message } = { message: params?.message ?? validationMessages.email };
+        const emailRegExp = 
+        // eslint-disable-next-line no-control-regex
+        /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|[\x01-\x09\x0B\x0C\x0E-\x7F])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21-\x5A\x53-\x7F]|\\[\x01-\x09\x0B\x0C\x0E-\x7F])+)])$/i;
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const stringedVal = typeof val === 'string' ? String(val) : undefined;
+                return stringedVal && emailRegExp.test(stringedVal) ? undefined : message();
+            }
+            return undefined;
+        };
+    };
+    const lettersOnly = (params) => {
+        const { message, whiteSpaces = false } = { ...params, message: params?.message ?? validationMessages.lettersOnly };
+        const lettersRegex = whiteSpaces ? /^[а-яА-Яa-zA-Z\s]+$/ : /^[а-яА-Яa-zA-Z]+$/;
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const stringedVal = typeof val === 'string' ? String(val) : undefined;
+                return stringedVal && lettersRegex.test(stringedVal) ? undefined : message(whiteSpaces);
+            }
+            return undefined;
+        };
+    };
+    const allowedOnly = (params) => {
+        const { message, allowed } = { ...params, message: params?.message ?? validationMessages.allowedOnly };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                switch (true) {
+                    case !!allowed && Array.isArray(allowed):
+                        if (!allowed?.length) {
+                            return message('');
+                        }
+                        return allowed.includes(val) ? undefined : message(allowed.join(', '));
+                    default:
+                        return undefined;
+                }
+            }
+            return undefined;
+        };
+    };
+    const sameAs = (params) => {
+        const { message, key } = { ...params, message: params?.message ?? validationMessages.sameAs };
+        return ({ val, listValues }) => {
+            if (checkVal(val)) {
+                switch (true) {
+                    case typeof val === 'object':
+                        if (!listValues?.[key] || typeof listValues[key] !== 'object') {
+                            return message(String(key));
+                        }
+                        try {
+                            return JSON.stringify(val) === JSON.stringify(listValues[key]) ? undefined : message(String(key));
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    default:
+                        return String(val ?? '') === String(listValues?.[key] ?? '') ? undefined : message(String(key));
+                }
+            }
+            return undefined;
+        };
+    };
+    const notSameAs = (params) => {
+        const { message, key } = { ...params, message: params?.message ?? validationMessages.notSameAs };
+        return ({ val, listValues }) => {
+            if (checkVal(val)) {
+                switch (true) {
+                    case typeof val === 'object':
+                        if (!listValues?.[key] || typeof listValues[key] !== 'object') {
+                            return message(String(key));
+                        }
+                        try {
+                            return JSON.stringify(val) !== JSON.stringify(listValues[key]) ? undefined : message(String(key));
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    default:
+                        return String(val) === String(listValues?.[key]) ? undefined : message(String(key));
+                }
+            }
+            return undefined;
+        };
+    };
+    const required = (params) => {
+        const { message, byCondition } = { ...params, message: params?.message ?? validationMessages.required };
+        return ({ val, listValues, key }) => {
+            if (!checkVal(val))
+                return message();
+            if (byCondition && !byCondition({ val, listValues, key }))
+                return undefined;
+            if (typeof val === 'string' && !val.length)
+                return message();
+            if (val instanceof File && val.size < 1)
+                return message();
+            if (typeof val === 'number' && !String(val).length)
+                return message();
+            return undefined;
+        };
+    };
+    const password = (params) => {
+        const { message, length = 8, specialChars, numbers, lowerUpperCasePattern } = { ...params, message: { ...validationMessages.password, ...params?.message } };
+        return ({ val }) => {
+            if (!checkVal(val))
+                return undefined;
+            const str = String(val);
+            if (str.length < length) {
+                return message.length(length);
+            }
+            if (specialChars) {
+                const minCount = typeof specialChars === 'number' ? specialChars : 1;
+                const count = (str.match(/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/g) || []).length;
+                if (count < minCount) {
+                    return message.specialChars(minCount);
+                }
+            }
+            if (numbers) {
+                const minCount = typeof numbers === 'number' ? numbers : 1;
+                const count = (str.match(/[0-9]/g) || []).length;
+                if (count < minCount) {
+                    return message.numbers(minCount);
+                }
+            }
+            if (lowerUpperCasePattern) {
+                const hasLower = /[a-z]/.test(str);
+                const hasUpper = /[A-Z]/.test(str);
+                if (!hasLower || !hasUpper) {
+                    return message.lowerUpperCasePattern();
+                }
+            }
+            return undefined;
+        };
+    };
+    return { string, number, required, password, notSameAs, sameAs, array, boolean, email, finite, lettersOnly, phone, allowedOnly };
+};

package/dist/core/delivery/serverAction/CreateServerAction.d.ts

@@ -0,0 +1,12 @@
+import { RequestContext } from '../../../edges/context/index.js';
+import { error, fail, redirect } from '@sveltejs/kit';
+type Deps = {
+    context: Required<ReturnType<typeof RequestContext.current>['event']>;
+    utils: {
+        fail: typeof fail;
+        redirect: typeof redirect;
+        error: typeof error;
+    };
+};
+export declare const createServerAction: <T>(factory: (args: Deps) => T) => (() => T);
+export {};

package/dist/core/delivery/serverAction/CreateServerAction.js

@@ -0,0 +1,12 @@
+import { RequestContext } from '../../../edges/context/index.js';
+import { error, fail, redirect } from '@sveltejs/kit';
+import { EnvironmentUtil } from 'azure-net-tools';
+export const createServerAction = (factory) => {
+    return () => {
+        if (EnvironmentUtil.isBrowser) {
+            throw Error('Do not use actions on client side');
+        }
+        const context = RequestContext.current().event;
+        return factory({ context, utils: { fail, redirect, error } });
+    };
+};

package/dist/core/delivery/serverAction/index.d.ts

@@ -0,0 +1 @@
+export * from './CreateServerAction.js';

package/dist/core/delivery/serverAction/index.js

@@ -0,0 +1 @@
+export * from './CreateServerAction.js';

package/dist/core/index.d.ts

@@ -1,8 +1,7 @@
-export * from './infra/response/index.js';
-export * from './infra/resource/index.js';
-export * from './infra/httpService/index.js';
-export * from './infra/datasource/index.js';
-export * from './infra/query/index.js';
-export * from './classMirror/index.js';
-export * from './request/index.js';
-export * from './boundaryProvider/index.js';
+export * from './delivery/index.js';
+export * from './shared/request/index.js';
+export * from './shared/middleware/index.js';
+export * from './shared/classMirror/index.js';
+export * from './shared/cookie/index.js';
+export * from './shared/boundaryProvider/index.js';
+export * from './ui/index.js';

package/dist/core/index.js

@@ -1,8 +1,7 @@
-export * from './infra/response/index.js';
-export * from './infra/resource/index.js';
-export * from './infra/httpService/index.js';
-export * from './infra/datasource/index.js';
-export * from './infra/query/index.js';
-export * from './classMirror/index.js';
-export * from './request/index.js';
-export * from './boundaryProvider/index.js';
+export * from './delivery/index.js';
+export * from './shared/request/index.js';
+export * from './shared/middleware/index.js';
+export * from './shared/classMirror/index.js';
+export * from './shared/cookie/index.js';
+export * from './shared/boundaryProvider/index.js';
+export * from './ui/index.js';

package/dist/core/infra/index.d.ts

@@ -0,0 +1,5 @@
+export * from './response/index.js';
+export * from './resource/index.js';
+export * from './httpService/index.js';
+export * from './datasource/index.js';
+export * from './query/index.js';

package/dist/core/infra/index.js

@@ -0,0 +1,5 @@
+export * from './response/index.js';
+export * from './resource/index.js';
+export * from './httpService/index.js';
+export * from './datasource/index.js';
+export * from './query/index.js';

package/dist/core/infra/response/BaseResponse.d.ts

@@ -1,4 +1,4 @@
-import { HttpServiceResponse } from '../../index.js';
+import type { HttpServiceResponse } from '../httpService/index.js';
 type DeepKeys<T> = T extends object ? {
     [K in keyof T & string]: T[K] extends object ? K | `${K}.${DeepKeys<T[K]>}` : K;
 }[keyof T & string] : never;

package/dist/core/infra/response/BaseResponse.js

@@ -1,4 +1,3 @@
-import { HttpServiceResponse } from '../../index.js';
 export class ResponseBuilder {
     response;
     state;

package/dist/core/{boundaryProvider → shared/boundaryProvider}/Provider.js

@@ -1,10 +1,10 @@
-import { RequestContext } from '../../edges/context/index.js';
-import { browser } from '$app/environment';
+import { RequestContext } from '../../../edges/context/index.js';
+import { EnvironmentUtil } from 'azure-net-tools';
 const clientCache = new Map();
 const factoriesCache = new WeakMap();
 const providerProxyCache = new Map();
 const getProviderCache = (providerName) => {
-    if (browser) {
+    if (EnvironmentUtil.isBrowser) {
         if (!clientCache.has(providerName)) {
             clientCache.set(providerName, new Map());
         }
@@ -29,7 +29,7 @@ const getProviderCache = (providerName) => {
 export const createBoundaryProvider = (name, services, options) => {
     const { dependsOn = {} } = options ?? {};
     const providerFn = () => {
-        if (browser && providerProxyCache.has(name)) {
+        if (EnvironmentUtil.isBrowser && providerProxyCache.has(name)) {
             return providerProxyCache.get(name);
         }
         const cache = getProviderCache(name);
@@ -55,7 +55,7 @@ export const createBoundaryProvider = (name, services, options) => {
                 });
             }
             factories = services(deps);
-            if (browser) {
+            if (EnvironmentUtil.isBrowser) {
                 factoriesCache.set(services, factories);
             }
             return factories;
@@ -87,7 +87,7 @@ export const createBoundaryProvider = (name, services, options) => {
                 return [...new Set([...cachedKeys, ...factoryKeys])];
             }
         });
-        if (browser) {
+        if (EnvironmentUtil.isBrowser) {
             providerProxyCache.set(name, providerProxy);
         }
         return providerProxy;
@@ -108,7 +108,7 @@ export function cleanupProvider(name) {
         await Promise.all(promises);
         cache.clear();
     };
-    if (browser) {
+    if (EnvironmentUtil.isBrowser) {
         const cache = clientCache.get(name);
         if (cache) {
             void cleanupCache(cache);