@azure-net/kit 6.0.0-next.1 → 6.0.0-next.10

package/dist/delivery/presenter/RegisterProvider.js

@@ -0,0 +1,99 @@
+import { RequestContext } from '../../shared/request-context/Internal.js';
+import { BROWSER } from '../../external/tools/index.js';
+const bindInstanceMethods = (instance, selection) => {
+    const descriptors = new Map();
+    const selected = selection === true ? undefined : new Set(selection);
+    const seen = new Set();
+    let target = instance;
+    while (target && target !== Object.prototype && target !== Function.prototype) {
+        for (const key of selected ?? Reflect.ownKeys(target)) {
+            if (key === 'constructor' || seen.has(key))
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(target, key);
+            if (!descriptor)
+                continue;
+            seen.add(key);
+            // Never evaluate accessors, including getters returning functions or Svelte state.
+            if ('value' in descriptor && typeof descriptor.value === 'function')
+                descriptors.set(key, descriptor);
+            else if (selected)
+                throw new TypeError(`[RegisterProvider] Cannot bind non-method ${String(key)}.`);
+        }
+        if (selected && seen.size === selected.size)
+            break;
+        target = Object.getPrototypeOf(target);
+    }
+    if (selected) {
+        for (const key of selected) {
+            if (!descriptors.has(key))
+                throw new TypeError(`[RegisterProvider] Method ${String(key)} was not found or cannot be bound.`);
+        }
+    }
+    // Validate every write before changing ordinary instances, avoiding partial binding on errors.
+    for (const key of descriptors.keys()) {
+        const own = Object.getOwnPropertyDescriptor(instance, key);
+        if (own ? !own.configurable && !own.writable : !Object.isExtensible(instance)) {
+            throw new TypeError(`[RegisterProvider] Cannot bind protected method ${String(key)}.`);
+        }
+    }
+    for (const [key, descriptor] of descriptors) {
+        Object.defineProperty(instance, key, { ...descriptor, value: Function.prototype.bind.call(descriptor.value, instance) });
+    }
+};
+/**
+ * Registration is safe at module scope; the factory is called only by the returned accessor.
+ * scoped: per request on the server, per call in the browser.
+ * singleton: per request on the server, per registration in the browser.
+ * transient: a new instance on every call.
+ * No hydration, component context, effects or disposal are managed by this function.
+ */
+export function RegisterProvider(factory, options = {}) {
+    if (!options || typeof options !== 'object' || Array.isArray(options))
+        throw new TypeError('[RegisterProvider] Options must be an object.');
+    const { lifecycle = 'scoped', bindMethods = false } = options;
+    if (!['scoped', 'transient', 'singleton'].includes(lifecycle)) {
+        throw new TypeError(`[RegisterProvider] Unknown lifecycle: ${lifecycle}`);
+    }
+    if (typeof bindMethods !== 'boolean' && !Array.isArray(bindMethods))
+        throw new TypeError('[RegisterProvider] bindMethods must be a boolean or method list.');
+    const selection = Array.isArray(bindMethods) ? [...bindMethods] : bindMethods;
+    const requests = new WeakMap();
+    let clientInstance;
+    let constructing = false;
+    const create = () => {
+        if (constructing)
+            throw new Error('[RegisterProvider] Circular presenter dependency.');
+        constructing = true;
+        try {
+            const instance = factory();
+            if (!instance || (typeof instance !== 'object' && typeof instance !== 'function')) {
+                throw new TypeError('[RegisterProvider] Factory must return an instance.');
+            }
+            if ('then' in instance && typeof instance.then === 'function') {
+                // Consume a rejected async factory without allowing an unhandled rejection.
+                void Promise.resolve(instance).catch(() => undefined);
+                throw new TypeError('[RegisterProvider] Factory must be synchronous.');
+            }
+            if (selection === true || (Array.isArray(selection) && selection.length > 0))
+                bindInstanceMethods(instance, selection);
+            return instance;
+        }
+        finally {
+            constructing = false;
+        }
+    };
+    return () => {
+        if (lifecycle === 'transient')
+            return create();
+        if (BROWSER)
+            return lifecycle === 'singleton' ? (clientInstance ??= create()) : create();
+        // Weak keys do not retain finished requests or their presenter graphs.
+        const context = RequestContext.current();
+        let instance = requests.get(context);
+        if (!instance) {
+            instance = create();
+            requests.set(context, instance);
+        }
+        return instance;
+    };
+}

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

@@ -176,7 +176,8 @@ export const createRules = (validationMessages) => {
                     return message.base();
                 }
                 if (typeof maxDigitsAfterDot === 'number') {
-                    const digitsAfterDot = normalizedValue.split('.')[1]?.length ?? 0;
+                    const [coefficient, exponent = '0'] = normalizedValue.split(/e/i);
+                    const digitsAfterDot = Math.max(0, (coefficient.split('.')[1]?.length ?? 0) - Number(exponent));
                     if (digitsAfterDot > maxDigitsAfterDot) {
                         return message.maxDigitsAfterDot(maxDigitsAfterDot);
                     }

package/dist/delivery.d.ts

@@ -1,2 +1 @@
-export * from './external/edges/Edges.js';
 export * from './delivery/index.js';

package/dist/delivery.js

@@ -1,2 +1 @@
-export * from './external/edges/Edges.js';
 export * from './delivery/index.js';

package/dist/i18n/Internal.d.ts

@@ -0,0 +1,15 @@
+export interface TranslationLifecycle {
+    preloadTranslation(): Promise<void>;
+    initializeClient(): Promise<void>;
+    syncFromState(state: App.RequestContextState): void;
+    transformHtml(html: string): string;
+}
+export declare const translationManager: unique symbol;
+export interface TranslationManagerHandle {
+    readonly [translationManager]: true;
+}
+export type TranslationManagerFactory = (() => object) & TranslationManagerHandle;
+export type TranslationManagerSource = TranslationManagerFactory | TranslationManagerHandle;
+export declare const bindTranslationLifecycle: (manager: object, lifecycle: TranslationLifecycle) => void;
+export declare const getTranslationLifecycle: (manager: object) => TranslationLifecycle;
+export declare const getTranslationManagerLifecycle: (manager: TranslationManagerSource) => TranslationLifecycle;

package/dist/i18n/Internal.js

@@ -0,0 +1,11 @@
+const lifecycles = new WeakMap();
+export const bindTranslationLifecycle = (manager, lifecycle) => {
+    lifecycles.set(manager, lifecycle);
+};
+export const getTranslationLifecycle = (manager) => {
+    const lifecycle = lifecycles.get(manager);
+    if (!lifecycle)
+        throw new Error('[AzureNetKit:i18n] Expected a TranslationManager or a manager returned by createTranslations().');
+    return lifecycle;
+};
+export const getTranslationManagerLifecycle = (manager) => getTranslationLifecycle(typeof manager === 'function' ? manager() : manager);

package/dist/i18n/TranslationManager.d.ts

@@ -0,0 +1,19 @@
+import { createTranslations } from './Translations.svelte.js';
+import { type translationManager, type TranslationManagerHandle } from './Internal.js';
+import type { MessageLoader, Path, TranslationVariables } from './Types.js';
+export type TranslationManagerOptions<TMessages extends Record<string, MessageLoader>, TInitLocale extends Extract<keyof TMessages, string>> = Parameters<typeof createTranslations<TMessages, TInitLocale>>[0];
+/** A module-safe facade. Only the provider owns request-local reactive state. */
+export declare class TranslationManager<const TMessages extends Record<string, MessageLoader>, const TInitLocale extends Extract<keyof TMessages, string>> implements TranslationManagerHandle {
+    #private;
+    readonly [translationManager]: true;
+    constructor(options: TranslationManagerOptions<TMessages, TInitLocale>);
+    readonly t: (translation?: Path<Awaited<ReturnType<TMessages[TInitLocale]>>> | string | {
+        key: Path<Awaited<ReturnType<TMessages[TInitLocale]>>> | string;
+        vars?: TranslationVariables;
+    }, vars?: TranslationVariables) => string;
+    readonly switchLocale: (locale: Extract<keyof TMessages, string>) => Promise<void>;
+    readonly applyHtmlLocaleAttr: (html: string) => string;
+    readonly subscribeLocaleChangeEvent: (listener: (locale: Extract<keyof TMessages, string>) => void) => (() => void);
+    get locale(): Extract<keyof TMessages, string>;
+    get locales(): Readonly<Record<Extract<keyof TMessages, string>, Extract<keyof TMessages, string>>>;
+}

package/dist/i18n/TranslationManager.js

@@ -0,0 +1,26 @@
+import { createTranslations } from './Translations.svelte.js';
+import { bindTranslationLifecycle, getTranslationLifecycle } from './Internal.js';
+/** A module-safe facade. Only the provider owns request-local reactive state. */
+export class TranslationManager {
+    #factory;
+    constructor(options) {
+        this.#factory = createTranslations(options);
+        // Resolve on every lifecycle invocation, never capture a server request here.
+        bindTranslationLifecycle(this, {
+            preloadTranslation: () => getTranslationLifecycle(this.#factory()).preloadTranslation(),
+            initializeClient: () => getTranslationLifecycle(this.#factory()).initializeClient(),
+            syncFromState: (state) => getTranslationLifecycle(this.#factory()).syncFromState(state),
+            transformHtml: (html) => getTranslationLifecycle(this.#factory()).transformHtml(html)
+        });
+    }
+    t = (translation, vars) => this.#factory().t(translation, vars);
+    switchLocale = (locale) => this.#factory().switchLocale(locale);
+    applyHtmlLocaleAttr = (html) => this.#factory().applyHtmlLocaleAttr(html);
+    subscribeLocaleChangeEvent = (listener) => this.#factory().subscribeLocaleChangeEvent(listener);
+    get locale() {
+        return this.#factory().locale;
+    }
+    get locales() {
+        return this.#factory().locales;
+    }
+}

package/dist/i18n/Translations.svelte.d.ts

@@ -0,0 +1,20 @@
+import { type TranslationManagerFactory } from './Internal.js';
+import type { Path, TranslationCookieOptions, MessageLoader, TranslationVariables } from './Types.js';
+export declare const createTranslations: <const TMessages extends Record<string, MessageLoader>, const TInitLocale extends Extract<keyof TMessages, string>>(params: {
+    messages: TMessages;
+    initLang: TInitLocale;
+    cookieName?: string;
+    cookieOptions?: TranslationCookieOptions;
+    initLangFromAcceptLanguage?: boolean;
+    prefix?: string;
+}) => (() => {
+    switchLocale: (requestedLocale: Extract<keyof TMessages, string>) => Promise<void>;
+    applyHtmlLocaleAttr: (html: string) => string;
+    subscribeLocaleChangeEvent: (listener: (locale: Extract<keyof TMessages, string>) => void) => (() => void);
+    t: (translation?: string | {
+        key: string | Path<Awaited<ReturnType<TMessages[TInitLocale]>>, "", []>;
+        vars?: TranslationVariables;
+    } | Path<Awaited<ReturnType<TMessages[TInitLocale]>>, "", []>, vars?: TranslationVariables) => string;
+    readonly locale: Extract<keyof TMessages, string>;
+    locales: Readonly<Record<Extract<keyof TMessages, string>, Extract<keyof TMessages, string>>>;
+}) & TranslationManagerFactory;

package/dist/i18n/Translations.svelte.js

@@ -0,0 +1,254 @@
+import { bindTranslationLifecycle } from './Internal.js';
+import { RegisterProvider } from '../delivery/presenter/RegisterProvider.js';
+import { Cookies, TextUtil, BROWSER } from '../external/tools/index.js';
+import { RequestContext } from '../shared/request-context/Internal.js';
+const PLURAL_PATTERN = /{{\s*(\w+)\s*\|\s*plural\s*:(.*?)}}/g;
+const VARIABLE_PATTERN = /{{\s*(\w+)\s*}}/g;
+const normalizeLocale = (locale) => locale.trim().replaceAll('_', '-').toLowerCase();
+const parseAcceptLanguage = (value) => {
+    if (!value)
+        return [];
+    return value
+        .split(',')
+        .map((part, index) => {
+        const [locale = '', ...parameters] = part.trim().split(';');
+        const qualityParameter = parameters.find((parameter) => parameter.trim().toLowerCase().startsWith('q='));
+        const quality = qualityParameter ? Number(qualityParameter.split('=')[1]) : 1;
+        return { locale: locale.trim(), quality: Number.isFinite(quality) ? quality : 0, index };
+    })
+        .filter(({ locale, quality }) => locale.length > 0 && quality > 0)
+        .sort((left, right) => right.quality - left.quality || left.index - right.index)
+        .map(({ locale }) => locale);
+};
+export const createTranslations = (params) => {
+    const snapshotKey = params.prefix ?? 'default';
+    const availableLocales = Object.keys(params.messages);
+    const locales = Object.freeze(Object.fromEntries(availableLocales.map((locale) => [locale, locale])));
+    if (!Object.hasOwn(params.messages, params.initLang))
+        throw new Error('[AzureNetKit:i18n] initLang must exist in messages.');
+    const normalizedLocales = new Map();
+    const localeVariants = new Map();
+    for (const locale of availableLocales) {
+        const normalized = normalizeLocale(locale);
+        const base = normalized.split('-')[0];
+        normalizedLocales.set(normalized, locale);
+        if (base && !localeVariants.has(base))
+            localeVariants.set(base, locale);
+    }
+    const resolveLocale = (locale) => {
+        if (!locale)
+            return undefined;
+        const normalized = normalizeLocale(locale);
+        if (!normalized)
+            return undefined;
+        const exact = normalizedLocales.get(normalized);
+        if (exact)
+            return exact;
+        const base = normalized.split('-')[0];
+        return base ? (normalizedLocales.get(base) ?? localeVariants.get(base)) : undefined;
+    };
+    const factory = RegisterProvider(() => {
+        const translations = new Map();
+        const pendingLoads = new Map();
+        const localeListeners = new Set();
+        let locale = $state.raw(params.initLang);
+        let activeMessages = $state.raw({});
+        let synchronized = false;
+        let initializationPromise;
+        let switchRevision = 0;
+        const loadTranslation = (requestedLocale) => {
+            const resolvedLocale = resolveLocale(requestedLocale);
+            if (!resolvedLocale) {
+                return Promise.reject(new Error(`[AzureNetKit:i18n] Locale "${requestedLocale}" is not present in messages.`));
+            }
+            const cached = translations.get(resolvedLocale);
+            if (cached)
+                return Promise.resolve(cached);
+            const pending = pendingLoads.get(resolvedLocale);
+            if (pending)
+                return pending;
+            const request = Promise.resolve()
+                .then(() => params.messages[resolvedLocale]())
+                .then((loaded) => {
+                // Imported dictionaries are module-cached; request state must not expose that shared object.
+                const messages = BROWSER ? loaded : structuredClone(loaded);
+                translations.set(resolvedLocale, messages);
+                return messages;
+            })
+                .finally(() => {
+                if (pendingLoads.get(resolvedLocale) === request)
+                    pendingLoads.delete(resolvedLocale);
+            });
+            pendingLoads.set(resolvedLocale, request);
+            return request;
+        };
+        const getLocaleFromRequest = () => {
+            const event = RequestContext.current().event;
+            if (!event)
+                throw new Error('[AzureNetKit:i18n] RequestContext has no RequestEvent.');
+            const cookieLocale = params.cookieName ? resolveLocale(event.cookies.get(params.cookieName)) : undefined;
+            if (cookieLocale)
+                return cookieLocale;
+            if (params.initLangFromAcceptLanguage) {
+                for (const requestedLocale of parseAcceptLanguage(event.request.headers.get('accept-language'))) {
+                    if (requestedLocale === '*')
+                        return params.initLang;
+                    const resolvedLocale = resolveLocale(requestedLocale);
+                    if (resolvedLocale)
+                        return resolvedLocale;
+                }
+            }
+            return params.initLang;
+        };
+        const preloadTranslation = async (resolver) => {
+            if (BROWSER)
+                throw new Error('[AzureNetKit:i18n] preloadTranslation() is server-only.');
+            const revision = ++switchRevision;
+            const requestedLocale = resolver ? await resolver() : getLocaleFromRequest();
+            const resolvedLocale = resolveLocale(requestedLocale) ?? params.initLang;
+            const messages = await loadTranslation(resolvedLocale);
+            if (revision !== switchRevision)
+                return;
+            locale = resolvedLocale;
+            activeMessages = messages;
+            const state = RequestContext.current().state;
+            state.currLocale = resolvedLocale;
+            const snapshots = (state.i18n ??= {});
+            Object.defineProperty(snapshots, snapshotKey, { value: { locale }, enumerable: true, configurable: true, writable: true });
+        };
+        const getTranslation = (messageKey) => {
+            let current = activeMessages;
+            for (const key of messageKey.split('.')) {
+                if (typeof current === 'string' || !current || !Object.hasOwn(current, key))
+                    return undefined;
+                current = current[key];
+            }
+            return typeof current === 'string' ? current : undefined;
+        };
+        const translate = (messageKey, vars = {}) => {
+            let result = getTranslation(messageKey);
+            if (result === undefined)
+                return messageKey;
+            if (!result.includes('{{'))
+                return result;
+            result = result.replace(PLURAL_PATTERN, (_, variableName, titlesString) => {
+                const count = Number(vars[variableName]);
+                if (Number.isNaN(count)) {
+                    console.warn(`[AzureNetKit:i18n] Plural variable "${variableName}" is not numeric.`);
+                    return '';
+                }
+                return TextUtil.pluralize(count, titlesString.split(',').map((title) => title.trim()));
+            });
+            return result.replace(VARIABLE_PATTERN, (_, key) => (vars[key] === undefined ? '' : String(vars[key])));
+        };
+        const t = (translation, vars) => {
+            if (!translation)
+                return '';
+            const extended = typeof translation === 'object' ? translation : undefined;
+            return translate(String(extended?.key ?? translation), extended?.vars ?? vars);
+        };
+        const syncFromState = (state) => {
+            if (synchronized)
+                return;
+            const snapshot = state.i18n && Object.hasOwn(state.i18n, snapshotKey) ? state.i18n[snapshotKey] : undefined;
+            const nextLocale = resolveLocale(snapshot?.locale ?? state.currLocale);
+            if (snapshot && !nextLocale)
+                throw new Error('[AzureNetKit:i18n] Unsupported boot locale.');
+            synchronized = true;
+            ++switchRevision;
+            initializationPromise = undefined;
+            if (nextLocale)
+                locale = nextLocale;
+            activeMessages = translations.get(locale) ?? {};
+        };
+        const updateHtmlLocale = (currentLocale) => {
+            document.documentElement.lang = currentLocale;
+        };
+        const initializeClient = () => {
+            if (!BROWSER)
+                return Promise.resolve();
+            if (initializationPromise)
+                return initializationPromise;
+            // SSR marker is available before SvelteKit starts hydration; boot runs later.
+            const serverLocale = document.documentElement.getAttribute('data-azure-net-locale');
+            locale =
+                resolveLocale(serverLocale ?? undefined) ??
+                    resolveLocale((params.cookieName ? Cookies.get(params.cookieName) : undefined) ?? undefined) ??
+                    (params.initLangFromAcceptLanguage ? navigator.languages.map(resolveLocale).find(Boolean) : undefined) ??
+                    locale;
+            const revision = switchRevision;
+            const request = loadTranslation(locale)
+                .then((messages) => {
+                if (revision !== switchRevision) {
+                    if (initializationPromise === request)
+                        initializationPromise = undefined;
+                    return;
+                }
+                activeMessages = messages;
+                updateHtmlLocale(locale);
+            })
+                .catch((error) => {
+                if (initializationPromise === request)
+                    initializationPromise = undefined;
+                throw error;
+            });
+            initializationPromise = request;
+            return request;
+        };
+        const switchLocale = async (requestedLocale) => {
+            if (!BROWSER)
+                throw new Error('[AzureNetKit:i18n] switchLocale() is client-only.');
+            const resolvedLocale = resolveLocale(requestedLocale);
+            if (!resolvedLocale)
+                throw new Error(`[AzureNetKit:i18n] Locale "${requestedLocale}" is not present in messages.`);
+            const revision = ++switchRevision;
+            const messages = await loadTranslation(resolvedLocale);
+            if (revision !== switchRevision)
+                return;
+            locale = resolvedLocale;
+            activeMessages = messages;
+            if (params.cookieName) {
+                Cookies.set(params.cookieName, resolvedLocale, {
+                    path: '/',
+                    sameSite: 'Lax',
+                    ...params.cookieOptions
+                });
+            }
+            updateHtmlLocale(resolvedLocale);
+            for (const listener of localeListeners)
+                listener(resolvedLocale);
+        };
+        const subscribeLocaleChangeEvent = (listener) => {
+            if (!BROWSER)
+                throw new Error('[AzureNetKit:i18n] Locale change events are client-only.');
+            localeListeners.add(listener);
+            return () => localeListeners.delete(listener);
+        };
+        const applyHtmlLocaleAttr = (html) => html.replaceAll('%lang%', () => locale);
+        const manager = {
+            switchLocale,
+            applyHtmlLocaleAttr,
+            subscribeLocaleChangeEvent,
+            t,
+            get locale() {
+                return locale;
+            },
+            locales
+        };
+        const escapeAttribute = (value) => value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+        bindTranslationLifecycle(manager, {
+            preloadTranslation,
+            initializeClient,
+            syncFromState,
+            transformHtml: (html) => applyHtmlLocaleAttr(html).replace(/<html\b([^>]*)>/i, (_, attrs) => '<html' +
+                attrs.replace(/\s+(?:data-azure-net-locale|lang)\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, '') +
+                ' lang="' +
+                escapeAttribute(locale) +
+                '" data-azure-net-locale="' +
+                escapeAttribute(locale) +
+                '">')
+        });
+        return manager;
+    }, { lifecycle: 'singleton' });
+    return factory;
+};

package/dist/i18n/Types.d.ts

@@ -0,0 +1,30 @@
+export interface TranslationSnapshot {
+    locale: string;
+}
+declare global {
+    namespace App {
+        interface RequestContextState {
+            currLocale?: string;
+            i18n?: Record<string, TranslationSnapshot>;
+        }
+    }
+}
+export type Translation = string | {
+    [key: string]: Translation;
+};
+export type TranslationShape<T> = T extends string ? string : T extends Record<string, unknown> ? {
+    [K in keyof T]: TranslationShape<T[K]>;
+} : never;
+export type Path<T, Prefix extends string = '', Depth extends unknown[] = []> = T extends string ? never : T extends Record<string, unknown> ? {
+    [K in keyof T & string]: T[K] extends string ? `${Prefix}${K}` : Depth['length'] extends 12 ? `${Prefix}${K}.${string}` : Path<T[K], `${Prefix}${K}.`, [...Depth, unknown]>;
+}[keyof T & string] : never;
+export interface TranslationCookieOptions {
+    expires?: Date | number;
+    maxAge?: number;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+export type MessageLoader = () => Promise<Translation>;
+export type TranslationVariables = Record<string, unknown>;

package/dist/i18n/Types.js

@@ -0,0 +1 @@
+export {};

package/dist/i18n/index.d.ts

@@ -0,0 +1,3 @@
+export { createTranslations } from './Translations.svelte.js';
+export { TranslationManager, type TranslationManagerOptions } from './TranslationManager.js';
+export type { Translation, TranslationShape, TranslationSnapshot, TranslationCookieOptions, Path } from './Types.js';

package/dist/i18n/index.js

@@ -0,0 +1,2 @@
+export { createTranslations } from './Translations.svelte.js';
+export { TranslationManager } from './TranslationManager.js';

package/dist/infra/datasource/BaseDatasource.d.ts

@@ -1,16 +1,29 @@
-import { type IHttpServiceInstance, type IHttpServiceResponse } from '../http-service/HttpServiceInstance.js';
-import { type IQueryBuilderInstance } from '../query/index.js';
+import { type IHttpInstanceOptions, type IHttpServiceInstance, type IHttpServiceResponse } from '../http-service/HttpServiceInstance.js';
+import { type IQueryBuilderInstance, type IQueryBuilderSettings } from '../query/index.js';
 export type CreateRequestCallbackType<T> = (params: {
     http: IHttpServiceInstance;
     query: IQueryBuilderInstance;
 }) => Promise<IHttpServiceResponse<T>>;
+type HttpClientParams = {
+    http: IHttpServiceInstance;
+    httpOptions?: never;
+} | {
+    http?: never;
+    httpOptions?: IHttpInstanceOptions;
+};
+type QueryBuilderParams = {
+    query: IQueryBuilderInstance;
+    queryOptions?: never;
+} | {
+    query?: never;
+    queryOptions?: IQueryBuilderSettings;
+};
+type DatasourceParams = HttpClientParams & QueryBuilderParams;
 export declare class BaseHttpDatasource {
     protected readonly httpClient: IHttpServiceInstance;
     protected readonly query: IQueryBuilderInstance;
-    constructor(params: {
-        http?: IHttpServiceInstance;
-        query?: IQueryBuilderInstance;
-    });
+    constructor(params: DatasourceParams);
     private _createRawRequest;
     readonly createRawRequest: <T>(callback: CreateRequestCallbackType<T>) => Promise<IHttpServiceResponse<T>>;
 }
+export {};

package/dist/infra/datasource/BaseDatasource.js

@@ -1,11 +1,11 @@
-import { createHttpServiceInstance } from '../http-service/HttpServiceInstance.js';
-import { createQueryInstance } from '../query/index.js';
+import { HttpServiceInstance } from '../http-service/HttpServiceInstance.js';
+import { QueryBuilder } from '../query/index.js';
 export class BaseHttpDatasource {
     httpClient;
     query;
     constructor(params) {
-        this.httpClient = params.http ?? createHttpServiceInstance();
-        this.query = params.query ?? createQueryInstance();
+        this.httpClient = params.http ?? new HttpServiceInstance(params?.httpOptions);
+        this.query = params.query ?? new QueryBuilder(params?.queryOptions);
     }
     _createRawRequest(callback) {
         return callback({ http: this.httpClient, query: this.query });

package/dist/infra/http-service/HttpServiceInstance.d.ts

@@ -47,7 +47,7 @@ export declare class HttpServiceError<T> extends Error implements IHttpServiceEr
     response?: Response;
     constructor({ status, data, message, original, type, response }: Partial<IHttpServiceError<T>>);
 }
-export interface HttpInstanceNormalizedRequest {
+export interface IHttpInstanceNormalizedRequest {
     url: string | URL;
     method: HttpInstanceFetchMethods;
     headers: Headers;
@@ -60,9 +60,9 @@ export interface HttpInstanceNormalizedRequest {
     fetch: typeof fetch;
     requestInit: Omit<RequestInit, 'method' | 'headers' | 'body'>;
 }
-export type HttpInstanceOnRequest = (request: HttpInstanceNormalizedRequest) => void | Promise<void>;
-export type HttpInstanceOnError = (error: HttpServiceError<unknown>, request: HttpInstanceNormalizedRequest) => void | Promise<void>;
-export type HttpInstanceDoFetch = <T = unknown>(request: HttpInstanceNormalizedRequest) => Promise<IHttpServiceResponse<T>>;
+export type IHttpInstanceOnRequest = (request: IHttpInstanceNormalizedRequest) => void | Promise<void>;
+export type IHttpInstanceOnError = (error: HttpServiceError<unknown>, request: IHttpInstanceNormalizedRequest) => void | Promise<void>;
+export type IHttpInstanceDoFetch = <T = unknown>(request: IHttpInstanceNormalizedRequest) => Promise<IHttpServiceResponse<T>>;
 export interface IHttpInstanceOptions<T = unknown> extends Omit<RequestInit, 'headers' | 'method'> {
     headers?: NonNullable<RequestInit['headers']> | Record<string, string | undefined>;
     json?: unknown;
@@ -73,19 +73,29 @@ export interface IHttpInstanceOptions<T = unknown> extends Omit<RequestInit, 'he
     retry?: number;
     includeRaw?: boolean;
     responseFormat?: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
-    onRequest?: HttpInstanceOnRequest;
-    onError?: HttpInstanceOnError;
+    onRequest?: IHttpInstanceOnRequest;
+    onError?: IHttpInstanceOnError;
     onResponse?: (response: IHttpServiceResponse<T>) => void | Promise<void>;
-    doFetch?: HttpInstanceDoFetch;
+    doFetch?: IHttpInstanceDoFetch;
 }
-export type HttpInstanceRequestMethod = <T = unknown>(url: string | URL, options?: IHttpInstanceOptions<T>) => Promise<IHttpServiceResponse<T>>;
+export type IHttpInstanceRequestMethod = <T = unknown>(url: string | URL, options?: IHttpInstanceOptions<T>) => Promise<IHttpServiceResponse<T>>;
 export interface IHttpServiceInstance {
-    get: HttpInstanceRequestMethod;
-    post: HttpInstanceRequestMethod;
-    put: HttpInstanceRequestMethod;
-    delete: HttpInstanceRequestMethod;
-    patch: HttpInstanceRequestMethod;
-    head: HttpInstanceRequestMethod;
-    options: HttpInstanceRequestMethod;
+    get: IHttpInstanceRequestMethod;
+    post: IHttpInstanceRequestMethod;
+    put: IHttpInstanceRequestMethod;
+    delete: IHttpInstanceRequestMethod;
+    patch: IHttpInstanceRequestMethod;
+    head: IHttpInstanceRequestMethod;
+    options: IHttpInstanceRequestMethod;
+}
+export declare class HttpServiceInstance implements IHttpServiceInstance {
+    private readonly defaults;
+    readonly get: IHttpInstanceRequestMethod;
+    readonly post: IHttpInstanceRequestMethod;
+    readonly put: IHttpInstanceRequestMethod;
+    readonly delete: IHttpInstanceRequestMethod;
+    readonly patch: IHttpInstanceRequestMethod;
+    readonly head: IHttpInstanceRequestMethod;
+    readonly options: IHttpInstanceRequestMethod;
+    constructor(config?: IHttpInstanceOptions);
 }
-export declare const createHttpServiceInstance: (config?: IHttpInstanceOptions) => IHttpServiceInstance;