@azure-net/kit 1.3.5 → 1.4.0

package/dist/core/delivery/injectableDependencies/AsyncHelpers.d.ts

@@ -6,7 +6,7 @@ export interface AsyncActionResponse<T, D = unknown, CustomErrorField = never> {
 }
 type ActionOrThunk<Res> = Promise<Res> | (() => Promise<Res>);
 export declare const createAsyncHelpers: <Custom = unknown>(opts?: {
-    parseError?: ReturnType<typeof createErrorParser<Custom>>;
+    parseError?: ReturnType<typeof createErrorParser<unknown, Custom>>;
 }) => {
     createAsyncAction: <Res = unknown, Req = unknown>(action: ActionOrThunk<Res>, args?: {
         beforeSend?: (next: () => void, abort: () => void) => void | Promise<void>;

package/dist/core/delivery/injectableDependencies/AsyncHelpers.js

@@ -70,7 +70,6 @@ export const createAsyncHelpers = (opts) => {
                 const abort = () => resolve('abort');
                 Promise.resolve(args.beforeSend(next, abort)).catch((err) => {
                     console.error('Error in beforeSend:', err);
-                    // If beforeSend throws, treat it as abort
                     resolve('abort');
                 });
             });

package/dist/core/delivery/injectableDependencies/ErrorHandler.d.ts

@@ -13,8 +13,8 @@ export type ErrorType<T = unknown> = Error | HttpServiceError<T> | SchemaFail<T>
 export declare const baseParseHttpError: <T = unknown, D = never>(error: HttpServiceError<T>) => AppError<T, D>;
 export declare const baseParseSchemaError: <SchemaData = unknown, D = never>(error: SchemaFail<SchemaData>) => AppError<SchemaData, D>;
 export declare const baseParseBaseError: <D = never>(error: Error) => AppError<never, D>;
-export declare const createErrorParser: <Custom = unknown>(parsers?: {
-    parseBaseError?: typeof baseParseBaseError;
-    parseHttpError?: typeof baseParseHttpError;
-    parseSchemaError?: typeof baseParseSchemaError;
-}) => (<T>(error: ErrorType<T>) => AppError<T, Custom>);
+export declare const createErrorParser: <BaseError = unknown, Custom = unknown>(parsers?: {
+    parseBaseError?: typeof baseParseBaseError<Custom>;
+    parseHttpError?: typeof baseParseHttpError<BaseError, Custom>;
+    parseSchemaError?: typeof baseParseSchemaError<BaseError, Custom>;
+}) => (<T = unknown>(error: ErrorType<BaseError>) => AppError<T, Custom>);

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

@@ -1,4 +1,7 @@
 import { error, fail, redirect, type RequestEvent } from '@sveltejs/kit';
+type NoConflict<I, D> = {
+    [K in keyof I]: K extends keyof D ? never : I[K];
+};
 type Deps = {
     context: RequestEvent;
     utils: {
@@ -7,5 +10,6 @@ type Deps = {
         error: typeof error;
     };
 };
-export declare const createServerAction: <T>(factory: (args: Deps) => T) => (() => T);
+export declare const createServerAction: <T, I extends Record<string, unknown> = Record<string, unknown>>(factory: (args: Deps & NoConflict<I, Deps>) => T, inject?: I) => (() => T);
+export declare const createServerActionFactory: <I extends Record<string, unknown>>(inject: I) => <T>(factory: (args: Deps & NoConflict<I, Deps>) => T) => () => T;
 export {};

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

@@ -1,12 +1,22 @@
 import { RequestContext } from '../../../edges/context/index.js';
 import { error, fail, redirect } from '@sveltejs/kit';
 import { EnvironmentUtil } from 'azure-net-tools';
-export const createServerAction = (factory) => {
+export const createServerAction = (factory, inject) => {
     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 } });
+        const deps = {
+            context,
+            utils: { fail, redirect, error },
+            ...inject
+        };
+        return factory(deps);
+    };
+};
+export const createServerActionFactory = (inject) => {
+    return function createInjectedServerAction(factory) {
+        return createServerAction(factory, inject);
     };
 };

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

@@ -2,7 +2,6 @@ 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;
-type DeepValue<T, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? DeepValue<T[Key], Rest> : never : Path extends keyof T ? T[Path] : never;
 type ResponseBuilderState<TData, TMeta = unknown> = {
     data: TData;
     meta: TMeta;
@@ -15,12 +14,12 @@ export declare class ResponseBuilder<TData = unknown, TMeta = object, TWrapper =
     protected unwrapData(data: TWrapper): TData;
     mapUsing<TResource>(ResourceClass: new (data: TData) => {
         toPlainObject(): TResource;
-    }): ResponseBuilder<TResource, TMeta, TWrapper>;
+    }): this;
     mapCollectionUsing<TResource>(ResourceClass: new (data: ArrayElement<TData>) => {
         toPlainObject(): TResource;
-    }): ResponseBuilder<TResource[], TMeta, TWrapper>;
-    extract<TPath extends DeepKeys<TData>>(path: TPath): ResponseBuilder<DeepValue<TData, TPath>, TMeta, TWrapper>;
-    addMeta<TNewMeta extends Record<string, unknown>>(metaData: TNewMeta | ((current: TMeta) => TNewMeta)): ResponseBuilder<TData, TMeta & TNewMeta, TWrapper>;
+    }): this;
+    extract<TPath extends DeepKeys<TData>>(path: TPath): this;
+    addMeta<TNewMeta extends Record<string, unknown>>(metaData: TNewMeta | ((current: TMeta) => TNewMeta)): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<TData, TMeta & TNewMeta, TWrapper>;
     getData(): TData;
     get(): {
         data: TData;

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

@@ -13,7 +13,7 @@ export class ResponseBuilder {
     }
     mapUsing(ResourceClass) {
         const resource = new ResourceClass(this.state.data);
-        const newResponse = new ResponseBuilder(this.response);
+        const newResponse = new this.constructor(this.response);
         newResponse.state = {
             ...this.state,
             data: resource.toPlainObject()
@@ -25,7 +25,7 @@ export class ResponseBuilder {
             throw new Error('toCollection can only be used when data is an array');
         }
         const collection = this.state.data.map((dataElement) => new ResourceClass(dataElement).toPlainObject());
-        const newResponse = new ResponseBuilder(this.response);
+        const newResponse = new this.constructor(this.response);
         newResponse.state = {
             ...this.state,
             data: collection
@@ -43,7 +43,7 @@ export class ResponseBuilder {
                 throw new Error(`Path "${path}" not found in response data`);
             }
         }
-        const newResponse = new ResponseBuilder(this.response);
+        const newResponse = new this.constructor(this.response);
         newResponse.state = {
             ...this.state,
             data: result
@@ -52,7 +52,7 @@ export class ResponseBuilder {
     }
     addMeta(metaData) {
         const newMeta = typeof metaData === 'function' ? metaData(this.state.meta) : metaData;
-        const newResponse = new ResponseBuilder(this.response);
+        const newResponse = new this.constructor(this.response);
         newResponse.state = {
             ...this.state,
             meta: { ...this.state.meta, ...newMeta }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "1.3.5",
+  "version": "1.4.0",
   "files": [
     "dist",
     "!dist/**/*.test.*",