Feature Store Context and API setup (opendatahub-io#4509)

* Feature Store Context and API setup:
* Backend proxy setup
* Routes
* Context
* Hooks
* API
* Unit tests

* remove title icon

* import updates and few changes

* adding unit tests

* PR review updates

* Invalid project selector

* adding prefix in proxy

Author: dpanshug

.env.development

@@ -19,4 +19,7 @@ TRUSTYAI_TAIS_SERVICE_PORT=9443
 MODEL_REGISTRY_NAME=modelregistry-sample
 MODEL_REGISTRY_SERVICE_HOST=localhost
 MODEL_REGISTRY_SERVICE_PORT=8085
-MODEL_REGISTRY_NAMESPACE=odh-model-registries
+MODEL_REGISTRY_NAMESPACE=odh-model-registries
+
+FEAST_REGISTRY_SERVICE_HOST=localhost
+FEAST_REGISTRY_SERVICE_PORT=8443

backend/src/routes/api/service/featurestore/index.ts

@@ -0,0 +1,24 @@
+import { FeatureStoreKind } from '../../../../types';
+import { proxyService } from '../../../../utils/proxy';
+
+export default proxyService<FeatureStoreKind>(
+  {
+    apiGroup: 'feast.dev',
+    apiVersion: 'v1alpha1',
+    kind: 'FeatureStore',
+    plural: 'featurestores',
+  },
+  {
+    internalPort: 443,
+    suffix: '-registry-rest',
+    prefix: 'feast-',
+  },
+  {
+    // Use port forwarding for local development:
+    // kubectl port-forward -n <namespace> svc/feast-<name>-registry-rest 8443:443
+    host: process.env.FEAST_REGISTRY_SERVICE_HOST,
+    port: process.env.FEAST_REGISTRY_SERVICE_PORT,
+  },
+  (resource) =>
+    !!resource.status?.conditions?.find((c: any) => c.type === 'Registry' && c.status === 'True'),
+);

backend/src/types.ts

@@ -1313,6 +1313,52 @@ export type AuthKind = K8sResourceCommon & {
   };
 };
 
+export type FeatureStoreKind = K8sResourceCommon & {
+  metadata: {
+    name: string;
+    namespace: string;
+    annotations?: Record<string, string>;
+  };
+  spec: {
+    feastProject: string;
+    services: Record<string, any>;
+    authz?: {
+      kubernetes?: {
+        roles?: string[];
+      };
+      oidc?: {
+        secretRef: {
+          name: string;
+        };
+      };
+    };
+    cronJob?: Record<string, never>;
+    volumes?: Record<string, never>[];
+  };
+  status?: {
+    applied?: {
+      cronJob?: {
+        concurrencyPolicy: string;
+        containerConfigs: {
+          commands: string[];
+          image: string;
+        };
+        schedule: string;
+        startingDeadlineSeconds: number;
+        suspend: boolean;
+      };
+      feastProject: string;
+      services?: Record<string, any>;
+    };
+    clientConfigMap?: string;
+    conditions?: K8sCondition[];
+    cronJob?: string;
+    feastVersion?: string;
+    phase?: string;
+    serviceHostnames?: Record<string, string>;
+  };
+};
+
 export enum OdhPlatformType {
   OPEN_DATA_HUB = 'Open Data Hub',
   SELF_MANAGED_RHOAI = 'OpenShift AI Self-Managed',

frontend/src/__mocks__/mockDataSources.ts

@@ -1,6 +1,6 @@
 /* eslint-disable camelcase */
 
-import { DataSource, DataSources } from '#~/concepts/featureStore/types.ts';
+import { DataSource, DataSources } from '#~/pages/featureStore/types';
 
 /* eslint-disable @typescript-eslint/naming-convention */
 export const mockDataSource_REQUEST_SOURCE = (partial?: Partial<DataSource>): DataSource => ({

frontend/src/__mocks__/mockEntities.ts

@@ -1,4 +1,5 @@
-import { Entities, Entity } from '#~/concepts/featureStore/types.ts';
+/* eslint-disable camelcase */
+import { Entity, EntityList } from '#~/pages/featureStore/types.ts';
 
 export const mockEntity = (partial?: Partial<Entity>): Entity => ({
   spec: {
@@ -24,6 +25,14 @@ export const mockEntity = (partial?: Partial<Entity>): Entity => ({
   ...partial,
 });
 
-export const mockEntities = ({ entities = [mockEntity({})] }: Partial<Entities>): Entities => ({
+export const mockEntities = ({ entities = [mockEntity({})] }: Partial<EntityList>): EntityList => ({
   entities,
+  pagination: {
+    page: 1,
+    limit: 10,
+    total_count: 1,
+    total_pages: 1,
+    has_next: false,
+    has_previous: false,
+  },
 });

frontend/src/__mocks__/mockFeatureServices.ts

@@ -1,5 +1,5 @@
 /* eslint-disable camelcase */
-import { FeatureService, FeatureServices } from '#~/concepts/featureStore/types.ts';
+import { FeatureService, FeatureServices } from '#~/pages/featureStore/types.ts';
 
 export const mockFeatureService = (partial?: Partial<FeatureService>): FeatureService => ({
   spec: {

frontend/src/__mocks__/mockFeatureStoreProject.ts

@@ -1,4 +1,4 @@
-import { FeatureStoreProject } from '#~/concepts/featureStore/types.ts';
+import { FeatureStoreProject } from '#~/pages/featureStore/types';
 
 export const mockFeatureStoreProject = (
   partial?: Partial<FeatureStoreProject>,

frontend/src/__mocks__/mockFeatureViews.ts

@@ -1,5 +1,5 @@
 /* eslint-disable camelcase */
-import { FeatureView } from '#~/concepts/featureStore/types.ts';
+import { FeatureView } from '#~/pages/featureStore/types';
 
 export const mockFeatureView = (partial?: Partial<FeatureView>): FeatureView => ({
   featureView: {

frontend/src/api/featureStore/__tests__/custom.spec.ts

@@ -0,0 +1,94 @@
+import { proxyGET } from '#~/api/proxyUtils';
+import { handleFeatureStoreFailures } from '#~/api/featureStore/errorUtils';
+import { listFeatureStoreProject, getEntities } from '#~/api/featureStore/custom';
+import { FEATURE_STORE_API_VERSION } from '#~/pages/featureStore/const';
+
+const mockProxyPromise = Promise.resolve();
+
+jest.mock('#~/api/proxyUtils', () => ({
+  proxyGET: jest.fn(() => mockProxyPromise),
+}));
+
+jest.mock('#~/api/featureStore/errorUtils', () => ({
+  handleFeatureStoreFailures: jest.fn((promise) => promise),
+}));
+
+const proxyGETMock = jest.mocked(proxyGET);
+const handleFeatureStoreFailuresMock = jest.mocked(handleFeatureStoreFailures);
+
+describe('listFeatureStoreProject', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call proxyGET and handleFeatureStoreFailures to fetch projects', () => {
+    const hostPath = 'test-host';
+    const opts = { dryRun: true };
+
+    const result = listFeatureStoreProject(hostPath)(opts);
+
+    expect(proxyGETMock).toHaveBeenCalledTimes(1);
+    expect(proxyGETMock).toHaveBeenCalledWith(
+      hostPath,
+      `/api/${FEATURE_STORE_API_VERSION}/projects`,
+      opts,
+    );
+    expect(handleFeatureStoreFailuresMock).toHaveBeenCalledTimes(1);
+    expect(handleFeatureStoreFailuresMock).toHaveBeenCalledWith(mockProxyPromise);
+    expect(result).toBe(mockProxyPromise);
+  });
+
+  it('should work with empty options', () => {
+    const hostPath = 'test-host';
+    const opts = {};
+
+    listFeatureStoreProject(hostPath)(opts);
+
+    expect(proxyGETMock).toHaveBeenCalledWith(
+      hostPath,
+      `/api/${FEATURE_STORE_API_VERSION}/projects`,
+      opts,
+    );
+  });
+});
+
+describe('getEntities', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call proxyGET with all entities endpoint when no project is provided', () => {
+    const hostPath = 'test-host';
+    const opts = { dryRun: true };
+
+    const result = getEntities(hostPath)(opts);
+
+    expect(proxyGETMock).toHaveBeenCalledTimes(1);
+    expect(proxyGETMock).toHaveBeenCalledWith(
+      hostPath,
+      `/api/${FEATURE_STORE_API_VERSION}/entities/all`,
+      opts,
+    );
+    expect(handleFeatureStoreFailuresMock).toHaveBeenCalledTimes(1);
+    expect(handleFeatureStoreFailuresMock).toHaveBeenCalledWith(mockProxyPromise);
+    expect(result).toBe(mockProxyPromise);
+  });
+
+  it('should call proxyGET with project-specific endpoint when project is provided', () => {
+    const hostPath = 'test-host';
+    const opts = { dryRun: true };
+    const project = 'test-project';
+
+    const result = getEntities(hostPath)(opts, project);
+
+    expect(proxyGETMock).toHaveBeenCalledTimes(1);
+    expect(proxyGETMock).toHaveBeenCalledWith(
+      hostPath,
+      `/api/${FEATURE_STORE_API_VERSION}/entities?project=${encodeURIComponent(project)}`,
+      opts,
+    );
+    expect(handleFeatureStoreFailuresMock).toHaveBeenCalledTimes(1);
+    expect(handleFeatureStoreFailuresMock).toHaveBeenCalledWith(mockProxyPromise);
+    expect(result).toBe(mockProxyPromise);
+  });
+});

frontend/src/api/featureStore/__tests__/errorUtils.spec.ts

@@ -0,0 +1,117 @@
+/* eslint-disable camelcase */
+import { handleFeatureStoreFailures } from '#~/api/featureStore/errorUtils';
+import { FeatureStoreError } from '#~/pages/featureStore/types';
+import { NotReadyError } from '#~/utilities/useFetchState';
+
+const mockConsoleError = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+
+describe('handleFeatureStoreFailures', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    mockConsoleError.mockRestore();
+  });
+
+  it('should successfully return data when promise resolves with valid data', async () => {
+    const mockData = {
+      projects: [
+        {
+          spec: { name: 'test-project' },
+          meta: {
+            createdTimestamp: '2023-01-01T00:00:00Z',
+            lastUpdatedTimestamp: '2023-01-01T00:00:00Z',
+          },
+        },
+      ],
+      pagination: {
+        page: 1,
+        limit: 10,
+        total_count: 1,
+        total_pages: 1,
+        has_next: false,
+        has_previous: false,
+      },
+    };
+
+    const result = await handleFeatureStoreFailures(Promise.resolve(mockData));
+    expect(result).toStrictEqual(mockData);
+  });
+
+  it('should throw FeatureStoreError when promise resolves with error object', async () => {
+    const featureStoreError: FeatureStoreError = {
+      code: 'FEATURE_STORE_001',
+      message: 'Feature store not found',
+    };
+
+    await expect(handleFeatureStoreFailures(Promise.resolve(featureStoreError))).rejects.toThrow(
+      'Feature store not found',
+    );
+  });
+
+  it('should throw Error with message when promise rejects with FeatureStoreError', async () => {
+    const featureStoreError: FeatureStoreError = {
+      code: 'FEATURE_STORE_002',
+      message: 'Invalid project configuration',
+    };
+
+    await expect(handleFeatureStoreFailures(Promise.reject(featureStoreError))).rejects.toThrow(
+      new Error('Invalid project configuration'),
+    );
+  });
+
+  it('should re-throw NotReadyError when promise rejects with NotReadyError', async () => {
+    const notReadyError = new NotReadyError('API not ready');
+
+    await expect(handleFeatureStoreFailures(Promise.reject(notReadyError))).rejects.toThrow(
+      notReadyError,
+    );
+  });
+
+  it('should handle other common state errors and re-throw them', async () => {
+    const abortError = new Error('The operation was aborted');
+    abortError.name = 'AbortError';
+
+    await expect(handleFeatureStoreFailures(Promise.reject(abortError))).rejects.toThrow(
+      abortError,
+    );
+  });
+
+  it('should log and throw generic error for unknown errors', async () => {
+    const unknownError = new Error('Unknown error');
+
+    await expect(handleFeatureStoreFailures(Promise.reject(unknownError))).rejects.toThrow(
+      'Error communicating with feature store server',
+    );
+
+    expect(mockConsoleError).toHaveBeenCalledTimes(1);
+    expect(mockConsoleError).toHaveBeenCalledWith('Unknown feature store API error', unknownError);
+  });
+
+  it('should handle non-Error objects and throw generic error', async () => {
+    const invalidError = 'string error';
+
+    await expect(handleFeatureStoreFailures(Promise.reject(invalidError))).rejects.toThrow(
+      'Error communicating with feature store server',
+    );
+
+    expect(mockConsoleError).toHaveBeenCalledTimes(1);
+    expect(mockConsoleError).toHaveBeenCalledWith('Unknown feature store API error', invalidError);
+  });
+
+  it('should handle null/undefined errors', async () => {
+    // null causes an error when accessing .name property in isCommonStateError
+    await expect(handleFeatureStoreFailures(Promise.reject(null))).rejects.toThrow(
+      "Cannot read properties of null (reading 'name')",
+    );
+
+    // undefined also causes an error when accessing .name property
+    await expect(handleFeatureStoreFailures(Promise.reject(undefined))).rejects.toThrow(
+      "Cannot read properties of undefined (reading 'name')",
+    );
+
+    // These errors occur before console.error is called, so no console calls expected
+    expect(mockConsoleError).toHaveBeenCalledTimes(0);
+  });
+});