@azure-net/kit 0.5.1 → 0.6.2

package/dist/core/appLayers/AppLayers.d.ts

@@ -0,0 +1,6 @@
+export declare enum AppLayers {
+    INFRASTRUCTURE = "infrastructure",
+    DOMAIN = "domain",
+    APPLICATION = "application",
+    PRESENTATION = "presentation"
+}

package/dist/core/appLayers/AppLayers.js

@@ -0,0 +1,7 @@
+export var AppLayers;
+(function (AppLayers) {
+    AppLayers["INFRASTRUCTURE"] = "infrastructure";
+    AppLayers["DOMAIN"] = "domain";
+    AppLayers["APPLICATION"] = "application";
+    AppLayers["PRESENTATION"] = "presentation";
+})(AppLayers || (AppLayers = {}));

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

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

package/dist/core/appLayers/index.js

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

package/dist/core/{service/BaseService.d.ts → application/UseCasesHandler.d.ts}

@@ -1,5 +1,5 @@
 import { HttpServiceResponse } from '../httpService/index.js';
-export declare class BaseService {
+export declare class UseCasesHandler {
     protected transformResponse<TData extends object, TResult = TData, TKey extends keyof TData | undefined = undefined>(requestPromise: Promise<HttpServiceResponse<TData>>, options?: {
         responseModel?: {
             new (response: HttpServiceResponse<TData>): {

package/dist/core/{service/BaseService.js → application/UseCasesHandler.js}

@@ -1,5 +1,5 @@
 import { HttpServiceResponse } from '../httpService/index.js';
-export class BaseService {
+export class UseCasesHandler {
     async transformResponse(requestPromise, options) {
         const response = await requestPromise;
         if (options?.responseModel) {

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

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

package/dist/core/application/index.js

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

package/dist/core/boundaryProvider/Provider.d.ts

@@ -0,0 +1,19 @@
+type ServiceFactory<T> = () => T | Promise<T>;
+type ServiceMap = Record<string, ServiceFactory<unknown>>;
+type ResolvedServices<T extends ServiceMap> = {
+    [K in keyof T]: Awaited<ReturnType<T[K]>>;
+};
+type InferProviderType<T> = T extends ProviderWithType<infer S> ? ResolvedServices<S> : never;
+export interface ProviderWithType<T extends ServiceMap> {
+    (): ResolvedServices<T>;
+    __types__: T;
+}
+type ProviderFactory<T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>> = (context: {
+    [K in keyof D]: InferProviderType<D[K]>;
+}) => T;
+interface LayerProviderOptions<D> {
+    dependsOn?: D;
+}
+export declare const createBoundaryProvider: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: string, services: ProviderFactory<T, D>, options?: LayerProviderOptions<D>) => ProviderWithType<T>;
+export declare function cleanupProvider(name: string): void;
+export {};

package/dist/core/boundaryProvider/Provider.js

@@ -0,0 +1,126 @@
+import { RequestContext } from '../../edges/context/index.js';
+import { browser } from '$app/environment';
+const clientCache = new Map();
+const factoriesCache = new WeakMap();
+const providerProxyCache = new Map();
+const getProviderCache = (providerName) => {
+    if (browser) {
+        if (!clientCache.has(providerName)) {
+            clientCache.set(providerName, new Map());
+        }
+        return clientCache.get(providerName);
+    }
+    else {
+        const context = RequestContext.current();
+        if (!context.data.providers) {
+            context.data.providers = new Map();
+        }
+        const providers = context.data.providers;
+        if (!providers.has(providerName)) {
+            providers.set(providerName, new Map());
+        }
+        if (!context.data.providersToCleanup) {
+            context.data.providersToCleanup = new Set();
+        }
+        context.data.providersToCleanup.add(providerName);
+        return providers.get(providerName);
+    }
+};
+export const createBoundaryProvider = (name, services, options) => {
+    const { dependsOn = {} } = options ?? {};
+    const providerFn = () => {
+        if (browser && providerProxyCache.has(name)) {
+            return providerProxyCache.get(name);
+        }
+        const cache = getProviderCache(name);
+        let factories = null;
+        const getFactories = () => {
+            if (factories)
+                return factories;
+            if (factoriesCache.has(services)) {
+                factories = factoriesCache.get(services);
+                return factories;
+            }
+            const deps = {};
+            const depInstances = new Map();
+            for (const [depName, depProvider] of Object.entries(dependsOn)) {
+                deps[depName] = new Proxy({}, {
+                    get(_, serviceKey) {
+                        if (!depInstances.has(depName)) {
+                            depInstances.set(depName, depProvider());
+                        }
+                        const dep = depInstances.get(depName);
+                        return dep?.[serviceKey];
+                    }
+                });
+            }
+            factories = services(deps);
+            if (browser) {
+                factoriesCache.set(services, factories);
+            }
+            return factories;
+        };
+        const providerProxy = new Proxy({}, {
+            get(_, key) {
+                if (cache.has(key)) {
+                    return cache.get(key);
+                }
+                const factories = getFactories();
+                if (!(key in factories)) {
+                    throw new Error(`Service '${key}' not found in provider '${name}'`);
+                }
+                const factory = factories[key];
+                const instance = factory();
+                cache.set(key, instance);
+                return instance;
+            },
+            has(_, key) {
+                if (cache.has(key))
+                    return true;
+                const factories = getFactories();
+                return key in factories;
+            },
+            ownKeys() {
+                const factories = getFactories();
+                const cachedKeys = Array.from(cache.keys());
+                const factoryKeys = Object.keys(factories);
+                return [...new Set([...cachedKeys, ...factoryKeys])];
+            }
+        });
+        if (browser) {
+            providerProxyCache.set(name, providerProxy);
+        }
+        return providerProxy;
+    };
+    return providerFn;
+};
+export function cleanupProvider(name) {
+    const cleanupCache = async (cache) => {
+        const promises = [];
+        for (const [key, service] of cache.entries()) {
+            if (service && typeof service === 'object' && 'dispose' in service) {
+                const disposeResult = service.dispose();
+                if (disposeResult instanceof Promise) {
+                    promises.push(disposeResult.catch((err) => console.error(`Error disposing ${name}.${key}:`, err)));
+                }
+            }
+        }
+        await Promise.all(promises);
+        cache.clear();
+    };
+    if (browser) {
+        const cache = clientCache.get(name);
+        if (cache) {
+            void cleanupCache(cache);
+        }
+        providerProxyCache.delete(name);
+    }
+    else {
+        const context = RequestContext.current();
+        const providers = context.data.providers;
+        if (providers?.has(name)) {
+            const cache = providers.get(name);
+            void cleanupCache(cache);
+        }
+    }
+}

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

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

package/dist/core/boundaryProvider/index.js

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

package/dist/core/container/Container.d.ts

@@ -0,0 +1,8 @@
+type Factory<T> = () => T;
+export declare class DIContainer {
+    private factories;
+    private instances;
+    register<T>(token: new (...args: unknown[]) => T, factory: Factory<T>): void;
+    get<T>(token: new (...args: unknown[]) => T): T;
+}
+export {};

package/dist/core/container/Container.js

@@ -0,0 +1,19 @@
+export class DIContainer {
+    factories = new Map();
+    instances = new Map();
+    register(token, factory) {
+        this.factories.set(token, factory);
+    }
+    get(token) {
+        if (this.instances.has(token)) {
+            return this.instances.get(token);
+        }
+        const factory = this.factories.get(token);
+        if (!factory) {
+            throw new Error(`Factory for ${token.name} not registered`);
+        }
+        const instance = factory();
+        this.instances.set(token, instance);
+        return instance;
+    }
+}

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

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

package/dist/core/container/index.js

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

package/dist/core/index.d.ts

@@ -1,6 +1,8 @@
-export * from './service/index.js';
+export * from './application/index.js';
 export * from './response/index.js';
 export * from './httpService/index.js';
 export * from './datasource/index.js';
 export * from './request/index.js';
 export * from './query/index.js';
+export * from './container/index.js';
+export * from './boundaryProvider/index.js';

package/dist/core/index.js

@@ -1,6 +1,8 @@
-export * from './service/index.js';
+export * from './application/index.js';
 export * from './response/index.js';
 export * from './httpService/index.js';
 export * from './datasource/index.js';
 export * from './request/index.js';
 export * from './query/index.js';
+export * from './container/index.js';
+export * from './boundaryProvider/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "0.5.1",
+  "version": "0.6.2",
   "files": [
     "dist",
     "!dist/**/*.test.*",
@@ -129,6 +129,7 @@
     "test": "npm run test:unit -- --run && npm run test:e2e",
     "test:e2e": "playwright test",
     "semantic-release": "env-cmd semantic-release",
+    "precommit": "pnpm lint && pnpm check",
     "commit": "pnpm format && git add . && git-cz && git push",
     "release": "pnpm commit && pnpm semantic-release"
   }

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

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

package/dist/core/service/index.js

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