@apistudio/apim-cli/node_modules/@apic/studio-client-model/src/api-authoring/store/api-mocking-store.model.ts

CLI for API Management Products

/**
 * Copyright IBM Corp. 2024, 2025
 */


import { AssetInfo } from "../../lfs/models/asset-info.model.js";
import { Project } from "../../lfs/models/project.model.js";
import { VCSProject } from "../../vcs/models/vcs-project.model.js";
import { VCSFileInfo } from "../../vcs/models/vcs-file-info.model.js";
import { FormViewTableData } from "../../component-models/models/form-view-table-data.model.js";
import { Metadata } from "../../common/models/base-asset.model.js";
import { FileAccessType } from "../interfaces/api-spec-handler.interface.js";
import { APICFileInfo } from "../../apic-mode/models/apic-file-info.model.js";
import { APICProject } from "../../apic-mode/models/apic-project.model.js";




export interface ApiMockInfo extends AssetInfo {
  project: Project | VCSProject | APICProject;
  apiFileHandle: FileSystemFileHandle | VCSFileInfo | APICFileInfo;
  enableMocking: boolean;
  tags: string[];

}
export type ApiMockStoreModel = {
  apiMock: ApiMockInfo | null;
  data: ApiMockingSpec;
  routeFileHandle: FileSystemFileHandle | VCSFileInfo | APICFileInfo | null;
  activeResourcePath: string,
  activeResourceMethod: string,
  isValidPolicySequenceArray: {
    state: boolean,
    reason: string
  },
  isValidRouteArrayInPolicySequence: {
    state: boolean,
    reason: string
  },
}


interface ApiResponse {
  $ref: string;
}

interface ApiMockResponse {
  endpoint: {
    file: FileAccessType;
    content: string;
  };
  route: {
    file: FileAccessType;
    content: string;
  };
  policyseq: {
    file: FileAccessType;
    content: string;
  };
}

interface ConditionalResponse {
  condition: string;
  statusCode: number;
  response: ApiResponse;
}


interface MethodResponses {
  defaultResponse: {
    [statusCode: number]:
    {
      response: ApiResponse;
    }
  };
  conditionalResponse?: ConditionalResponse[];
}


interface Paths {
  [path: string]: {
    [method: string]: MethodResponses;
  };
}


interface ApiMockingSpec {

  paths: Paths;

}


export interface ResponseHeader extends FormViewTableData {
  Key: string;
  Value: string
}

export interface ResponseBody extends FormViewTableData {
  'Content-type': string;
  'payload': string;
}

export interface ApiMockingStoreActions {
  addApiMock: (scopeInfo: ApiMockInfo) => Promise<ApiMockResponse | undefined>;
  //setEnableMocking: (enable: boolean) => void;
  setRouteFileHandle: (fileHandle: FileSystemFileHandle | VCSFileInfo | APICFileInfo | null) => void;
  setApiMock: (apiMock: ApiMockInfo | null) => void;
  setValidPolicySequenceArray: (data: {
    state: boolean,
    reason: string
  }) => void;
  setValidRouteArrayInPolicySequence: (data: {
    state: boolean,
    reason: string
  }) => void;
  setData: (data: { paths: Record<string, any> }) => void;
  setActiveResourcePath: (path: string) => void;
  setActiveResourceMethod: (method: string) => void;
  setEnableMocking: (bool: boolean) => void;
  addStaticResponse: (statuscode: string, responseDetails: {
    name: string,
    namespace: string,
    version: string,
    project: string,
    tags: string[]
  }, headerData: ResponseHeader[], body: ResponseBody[]) => Promise<{
    file: FileAccessType;
    content: string;
  } | undefined>;
  addConditionalResponse: (condition: string, statuscode: string, responseDetails: {
    name: string,
    namespace: string,
    version: string,
    project: string,
    tags: string[]
  }, headerData: ResponseHeader[], body: ResponseBody[]) => Promise<{
    file: FileAccessType;
    content: string;
  } | undefined>;
  updateStaticResponse: (prevStatusCode: string, statuscode: string, responseDetails: {
    name: string,
    namespace: string,
    version: string,
    project: string,
    tags: string[]
  }, headerData: ResponseHeader[], body: ResponseBody[], mockResponseFile: FileAccessType, mockResponseProject: Project | VCSProject | APICProject) => Promise<void>;
  deleteStaticResponse: (statuscode: string) => Promise<void>;
  updateConditionalResponse: (condition: string, index: number, statuscode: string, responseDetails: {
    name: string,
    namespace: string,
    version: string,
    project: string,
    tags: string[]
  }, headerData: ResponseHeader[], body: ResponseBody[], mockResponseFile: FileAccessType, mockResponseProject: Project | VCSProject | APICProject) => Promise<void>;
  deleteConditionalResponse: (index: number) => Promise<void>;
  refreshData: () => Promise<void>;
  updateEndpointMetadata: (metadata: Metadata) => Promise<void>;
  updateMockResponse: (statuscode: string, responseDetails: {
    name: string,
    namespace: string,
    version: string,
    project: string,
    tags: string[]
  }, headerData: ResponseHeader[], body: ResponseBody[], mockResponseFile: FileAccessType, mockResponseProject: Project | VCSProject | APICProject, condition?: string) => Promise<void>;
}