http-request-manager 18.15.32 → 18.15.34

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

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

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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,13 @@
+/**
+ * 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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,169 @@
+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
+    });
+  }
+}