http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/request-manager-state-service/index.ts

@@ -1,3 +0,0 @@
-export * from "./http-manager-state.store";
-
-export * from "./models/index";

package/src/lib/services/request-manager-state-service/models/api-request.model.ts

@@ -1,86 +0,0 @@
-import { RetryOptions } from "../../request-manager-services"
-import { WSOptions } from "./ws-options.model"
-import { StreamType } from "./stream-type.enum"
-
-export interface ApiRequestInterface {
-  server: string
-  path?: any[]
-  headers?: any
-  adapter?: any
-  mapper?: any
-  polling?: number // seconds (undefined | 0 = none)
-  retry?: RetryOptions
-  stream?: boolean
-  streamType?: StreamType
-  displayError?: boolean
-  displaySuccess?: boolean
-  successMessage?: string
-  errorMessage?: string
-  saveAs?: string
-  fileContentHeader?: string
-  ws?: WSOptions // Websocket Options
-  env?: string // Environment for WebSocket channel naming
-  uploadFiles?: File | File[]
-  uploadFieldName?: string
-  uploadHttpMethod?: 'POST' | 'PUT'
-  allowedTypes?: string[]
-  maxFileSize?: number
-  maxTotalSize?: number
-}
-
-export class ApiRequest implements ApiRequestInterface {
-  constructor(
-    public server = '',
-    public path?: any[],
-    public headers?: any,
-    public adapter?: any,
-    public mapper?: any,
-    public polling?: number,
-    public retry?: RetryOptions,
-    public stream?: boolean,
-    public streamType?: StreamType,
-    public displayError?: boolean,
-    public displaySuccess?: boolean,
-    public successMessage?: string,
-    public errorMessage?: string,
-    public saveAs?: string,
-    public fileContentHeader?: string,
-    public ws?: WSOptions,
-    public env?: string,
-    public uploadFiles?: File | File[],
-    public uploadFieldName?: string,
-    public uploadHttpMethod?: 'POST' | 'PUT',
-    public allowedTypes?: string[],
-    public maxFileSize?: number,
-    public maxTotalSize?: number,
-  ) {}
-
-  static adapt(item?: any): ApiRequest {
-    const server = Array.isArray(item?.server) ? item.server.join('/') : item?.server || '';
-    return new ApiRequest(
-      server,
-      item?.path ? item.path : [],
-      item?.headers ? item.headers : {},
-      item?.adapter,
-      item?.mapper,
-      item?.polling ? Math.floor(item.polling) : 0,
-      item?.retry ? RetryOptions.adapt(item.retry) : RetryOptions.adapt(),
-      item?.stream ? item.stream : false,
-      item?.streamType || StreamType.AI_STREAMING,
-      item?.displayError ? item.displayError : false,
-      item?.displaySuccess ? item.displaySuccess : false,
-      item?.successMessage,
-      item?.errorMessage,
-      item?.saveAs,
-      item?.fileContentHeader,
-      item?.ws,
-      item?.env || 'dev',
-      item?.uploadFiles,
-      item?.uploadFieldName,
-      item?.uploadHttpMethod,
-      Array.isArray(item?.allowedTypes) ? item.allowedTypes : [],
-      item?.maxFileSize,
-      item?.maxTotalSize,
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/index.ts

@@ -1,14 +0,0 @@
-export * from "./api-request.model";
-export * from "./request-options.model";
-export * from "./stream-type.enum";
-
-export * from "./ws-options.model";
-export * from "./operation-result.model";
-
-export * from "./stream-config.model";
-export * from "./stream-progress.model";
-export * from "./stream-output.model";
-export * from "./stream-event-metadata.model";
-export * from "./stream-event.model";
-export * from "./parsing-result.model";
-

package/src/lib/services/request-manager-state-service/models/operation-result.model.ts

@@ -1,18 +0,0 @@
-export interface OperationResultInterface {
-  success: boolean;
-  operation: 'CREATE' | 'UPDATE' | 'DELETE';
-}
-
-export class OperationResultModel implements OperationResultInterface {
-  constructor(
-    public success: boolean = false,
-    public operation: 'CREATE' | 'UPDATE' | 'DELETE' = 'UPDATE',
-  ) {}
-
-  static adapt(item?: any): OperationResultModel {
-    return new OperationResultModel(
-      item?.success ?? false,
-      item?.operation || 'UPDATE',
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/parsing-result.model.ts

@@ -1,21 +0,0 @@
-export interface ParsingResultInterface<T = any> {
-  success: boolean;
-  data?: T[];
-  error?: string;
-}
-
-export class ParsingResultModel<T = any> implements ParsingResultInterface<T> {
-  constructor(
-    public success: boolean = false,
-    public data?: T[],
-    public error?: string
-  ) {}
-
-  static adapt<T = any>(item?: any): ParsingResultModel<T> {
-    return new ParsingResultModel<T>(
-      item?.success,
-      Array.isArray(item?.data) ? item.data : undefined,
-      item?.error
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/request-options.model.ts

@@ -1,37 +0,0 @@
-export interface RequestOptionsInterface {
-    path: any[],
-    headers: any,
-  forceRefresh?: boolean,
-  ignoreQueryParams?: string[],
-  queryParamsExpiresIn?: string | number,
-  watchParams?: string[],
-  watchExpiresAt?: number,
-}
-
-export class RequestOptions implements RequestOptionsInterface {
-
-  constructor(
-    public path: any[] = [],
-    public headers = {},
-    public forceRefresh?: boolean,
-    public ignoreQueryParams?: string[],
-    public queryParamsExpiresIn?: string | number,
-    public watchParams?: string[],
-    public watchExpiresAt?: number,
-  ) {}
-
-  static adapt(item?: any): RequestOptions {
-
-    return new RequestOptions(
-      item?.path,
-      item?.headers,
-      item?.forceRefresh,
-      Array.isArray(item?.ignoreQueryParams) ? item.ignoreQueryParams : [],
-      item?.queryParamsExpiresIn,
-      item?.watchParams,
-      item?.watchExpiresAt,
-    )
-
-  }
-
-}

package/src/lib/services/request-manager-state-service/models/stream-config.model.ts

@@ -1,20 +0,0 @@
-import { StreamType } from './stream-type.enum';
-
-export interface StreamConfigInterface {
-  streamType: StreamType;
-  totalHeader?: string;
-}
-
-export class StreamConfigModel implements StreamConfigInterface {
-  constructor(
-    public streamType: StreamType = StreamType.AI_STREAMING,
-    public totalHeader: string = 'X-Total-Count'
-  ) {}
-
-  static adapt(item?: any): StreamConfigModel {
-    return new StreamConfigModel(
-      item?.streamType,
-      item?.totalHeader
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/stream-event-metadata.model.ts

@@ -1,23 +0,0 @@
-import { StreamType } from './stream-type.enum';
-
-export interface StreamEventMetadataInterface {
-  timestamp: Date;
-  streamType: StreamType;
-  contentLength?: number;
-}
-
-export class StreamEventMetadataModel implements StreamEventMetadataInterface {
-  constructor(
-    public timestamp: Date = new Date(),
-    public streamType: StreamType = StreamType.AI_STREAMING,
-    public contentLength?: number
-  ) {}
-
-  static adapt(item?: any): StreamEventMetadataModel {
-    return new StreamEventMetadataModel(
-      item?.timestamp,
-      item?.streamType,
-      item?.contentLength
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/stream-event.model.ts

@@ -1,23 +0,0 @@
-import { StreamEventMetadataModel } from './stream-event-metadata.model';
-
-export interface StreamEventInterface<T = any> {
-  type: 'progress' | 'complete' | 'data';
-  data: T;
-  metadata?: StreamEventMetadataModel;
-}
-
-export class StreamEventModel<T = any> implements StreamEventInterface<T> {
-  constructor(
-    public type: 'progress' | 'complete' | 'data' = 'data',
-    public data: T = null as any,
-    public metadata?: StreamEventMetadataModel
-  ) {}
-
-  static adapt<T = any>(item?: any): StreamEventModel<T> {
-    return new StreamEventModel<T>(
-      item?.type,
-      item?.data,
-      item?.metadata ? StreamEventMetadataModel.adapt(item.metadata) : undefined
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/stream-output.model.ts

@@ -1,23 +0,0 @@
-import { StreamProgressModel } from './stream-progress.model';
-
-export interface StreamOutputInterface<T = any> {
-  data: T[];
-  progress: StreamProgressModel;
-  endpoint?: string;
-}
-
-export class StreamOutputModel<T = any> implements StreamOutputInterface<T> {
-  constructor(
-    public data: T[] = [],
-    public progress: StreamProgressModel = new StreamProgressModel(),
-    public endpoint?: string
-  ) {}
-
-  static adapt<T = any>(item?: any): StreamOutputModel<T> {
-    return new StreamOutputModel<T>(
-      Array.isArray(item?.data) ? item.data : [],
-      item?.progress ? StreamProgressModel.adapt(item.progress) : new StreamProgressModel(),
-      item?.endpoint
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/stream-progress.model.ts

@@ -1,24 +0,0 @@
-export interface StreamProgressInterface {
-  received: number;
-  total?: number;
-  percent: number;
-  stage: 'connecting' | 'streaming' | 'complete' | 'error';
-}
-
-export class StreamProgressModel implements StreamProgressInterface {
-  constructor(
-    public received: number = 0,
-    public total?: number,
-    public percent: number = 0,
-    public stage: 'connecting' | 'streaming' | 'complete' | 'error' = 'connecting'
-  ) {}
-
-  static adapt(item?: any): StreamProgressModel {
-    return new StreamProgressModel(
-      item?.received,
-      item?.total,
-      item?.percent,
-      item?.stage
-    );
-  }
-}

package/src/lib/services/request-manager-state-service/models/stream-type.enum.ts

@@ -1,13 +0,0 @@
-/**
- * Enum representing valid streaming format types
- * 
- * This enum defines all supported streaming formats for HTTP requests.
- * Each enum value corresponds to a specific data format and parsing strategy.
- */
-export enum StreamType {
-  JSON = 'json',
-  NDJSON = 'ndjson', 
-  AI_STREAMING = 'ai_streaming',
-  EVENT_STREAM = 'event_stream',
-  AUTO = 'auto'
-}

package/src/lib/services/request-manager-state-service/models/ws-options.model.ts

@@ -1,42 +0,0 @@
-import { RetryOptions } from "../../request-manager-services"
-
-export interface WSOptionsInterface {
-    id: string,
-    wsServer: string,
-    jwtToken: string,
-    permissions?: string[],
-    channels?: string[],
-    wsUpdateChannels?: string[],
-    user?: any,
-    retry?: RetryOptions
-}
-
-export class WSOptions implements WSOptionsInterface {
-
-  constructor(
-    public id: string = '',
-    public wsServer: string = '',
-    public jwtToken: string = '',
-    public permissions?: string[],
-    public channels?: string[],
-    public wsUpdateChannels?: string[],
-    public user?: any,
-    public retry?: RetryOptions
-  ) {}
-
-  static adapt(item?: any): WSOptions {
-
-    return new WSOptions(
-      item?.id,
-      item?.wsServer,
-      item?.jwtToken,
-      (item?.permissions) ? item.permissions.split(',').map((p: string) => p.trim()) : [],
-      item?.channels,
-      item?.wsUpdateChannels,
-      item?.user,
-      item?.retry
-    )
-
-  }
-
-}

package/src/lib/services/store-state-manager-service/index.ts

@@ -1,4 +0,0 @@
-export * from "./store-state-manager.service";
-export { StoreStateManagerSignalsService } from "./store-state-manager-signals.service";
-
-export * from "./models/index";

package/src/lib/services/store-state-manager-service/models/index.ts

@@ -1,3 +0,0 @@
-export * from "./state-storage-options.model";
-export * from "./state-operation-result.model";
-

package/src/lib/services/store-state-manager-service/models/state-operation-result.model.ts

@@ -1,30 +0,0 @@
-export interface StateOperationResultInterface {
-  success: boolean;
-  operation: 'CREATE' | 'UPDATE' | 'DELETE';
-  key?: string;
-  value?: any;
-  timestamp: number;
-  error?: string;
-}
-
-export class StateOperationResult implements StateOperationResultInterface {
-  constructor(
-    public success: boolean = false,
-    public operation: 'CREATE' | 'UPDATE' | 'DELETE' = 'UPDATE',
-    public key?: string,
-    public value?: any,
-    public timestamp: number = Date.now(),
-    public error?: string,
-  ) {}
-
-  static adapt(item?: any): StateOperationResult {
-    return new StateOperationResult(
-      item?.success ?? false,
-      item?.operation || 'UPDATE',
-      item?.key,
-      item?.value,
-      item?.timestamp || Date.now(),
-      item?.error,
-    );
-  }
-}

package/src/lib/services/store-state-manager-service/models/state-storage-options.model.ts

@@ -1,24 +0,0 @@
-import { SettingOptions } from "../../local-storage-manager-service";
-
-export interface StateStorageOptionsInterface {
-  store?: string;
-  options?: SettingOptions;
-  model?: (state: any) => any;
-}
-
-export class StateStorageOptions implements StateStorageOptionsInterface {
-
-  constructor(
-    public store?: string,
-    public options?: SettingOptions,
-    public model?: (state: any) => any
-  ) {}
-
-  static adapt(item?: any): StateStorageOptions {
-    return new StateStorageOptions(
-      item?.store ?? 'temp',
-      item?.options ? SettingOptions.adapt(item.options) : SettingOptions.adapt(),
-      item?.model
-    );
-  }
-}

package/src/lib/services/store-state-manager-service/store-state-manager-signals.service.ts

@@ -1,169 +0,0 @@
-import { Injectable, inject, WritableSignal, signal, computed, effect } from '@angular/core';
-
-import { LocalStorageSignalsManagerService } from '../local-storage-manager-service/local-storage-signals-manager.service';
-import { StateStorageOptions } from './models/state-storage-options.model';
-import { StateOperationResult } from './models/state-operation-result.model';
-import { SettingOptions } from '../local-storage-manager-service';
-
-export interface StateStoreManagerData<T> {}
-
-@Injectable({
-  providedIn: 'root'
-})
-export class StoreStateManagerSignalsService<T extends object = StateStoreManagerData<any>> {
-
-  private localStorageManagerService = inject(LocalStorageSignalsManagerService);
-  private state = signal<T | null>(null);
-  private isRestoring = false;
-  private settings: StateStorageOptions | null = null;
-
-  private operationResultSignal = signal<StateOperationResult | null>(null)
-  readonly operationResult = this.operationResultSignal.asReadonly();
-
-  // Public readonly signals for consumers
-  readonly data = this.state.asReadonly();
-
-  // Computed signal for transformed data
-  readonly transformedData = computed(() => {
-    const s = this.state();
-    if (!s || !this.settings?.model) return s;
-    return this.settings.model(s);
-  });
-
-  constructor() {
-  }
-
-  init(options: StateStorageOptions) {
-    this.settings = options;
-    const storeName = options.store ?? 'temp';
-
-    // Create store in localStorage
-    this.localStorageManagerService.createStore({
-      name: storeName,
-      data: options.model ? options.model({}) : {},
-      options: options.options ?? SettingOptions.adapt(),
-    });
-
-    // Set initial state
-    const initialState = (options.model ? options.model({}) : {}) as T;
-    this.state.set(initialState);
-
-    // Auto-sync when localStorage data changes
-    effect(() => {
-      const storeData = this.localStorageManagerService.store(storeName)();
-      if (storeData && !this.isRestoring) {
-        this.state.set(storeData as T);
-      }
-    });
-  }
-
-  restoreState() {
-    if (!this.settings) return;
-    const storeName = this.settings.store ?? 'temp';
-    const storeData = this.localStorageManagerService.store(storeName)();
-    if (storeData) {
-      this.updateData(storeData as Partial<T>);
-    }
-  }
-
-  updateState(state: Partial<T>) {
-    if (this.isRestoring || !this.settings) return;
-    const storeName = this.settings.store ?? 'temp';
-
-    this.state.update(current => ({
-      ...current!,
-      ...state
-    } as T));
-
-    // Auto-persist to localStorage
-    this.localStorageManagerService.updateStore({
-      name: storeName,
-      data: this.state()
-    });
-  }
-
-  updateData(data: Partial<T>) {
-    const key = Object.keys(data)[0];
-    const currentState = this.state();
-
-    if (!currentState || !key) {
-      return;
-    }
-
-    const newState = { ...currentState, [key]: data[key as keyof T] } as T;
-    this.state.set(newState);
-    this.updateState(newState);
-  }
-
-  createRecord(key: string, value: any) {
-    try {
-      this.updateData({ [key]: value } as Partial<T>)
-      this.operationResultSignal.set(StateOperationResult.adapt({
-        success: true,
-        operation: 'CREATE',
-        key,
-        value,
-      }))
-    } catch (error: any) {
-      this.operationResultSignal.set(StateOperationResult.adapt({
-        success: false,
-        operation: 'CREATE',
-        key,
-        error: error?.message || 'Create failed',
-      }))
-    }
-  }
-
-  updateRecord(key: string, value: any) {
-    try {
-      this.updateData({ [key]: value } as Partial<T>)
-      this.operationResultSignal.set(StateOperationResult.adapt({
-        success: true,
-        operation: 'UPDATE',
-        key,
-        value,
-      }))
-    } catch (error: any) {
-      this.operationResultSignal.set(StateOperationResult.adapt({
-        success: false,
-        operation: 'UPDATE',
-        key,
-        error: error?.message || 'Update failed',
-      }))
-    }
-  }
-
-  deleteRecord(key: string) {
-    try {
-      const currentState = this.state();
-      if (currentState && key in currentState) {
-        const { [key]: removed, ...rest } = currentState as any
-        this.state.set(rest as T)
-        this.updateState(rest as Partial<T>)
-      }
-      this.operationResultSignal.set(StateOperationResult.adapt({
-        success: true,
-        operation: 'DELETE',
-        key,
-      }))
-    } catch (error: any) {
-      this.operationResultSignal.set(StateOperationResult.adapt({
-        success: false,
-        operation: 'DELETE',
-        key,
-        error: error?.message || 'Delete failed',
-      }))
-    }
-  }
-
-  resetState() {
-    if (!this.settings) return;
-    const storeName = this.settings.store ?? 'temp';
-    const initialState = (this.settings.model ? this.settings.model({}) : {}) as T;
-    this.state.set(initialState);
-    this.localStorageManagerService.updateStore({
-      name: storeName,
-      data: initialState
-    });
-  }
-}