@jh-tech/bff-update-feed-app-client 0.0.21 → 0.0.23

package/createClient.ts

@@ -0,0 +1,42 @@
+import { GetProjectFeedDef, GetUpdateFeedDef, SearchCreatorProjectDef } from '@jh-tech/bff-update-feed-app-shared'
+import { ProcessingMethods } from 'jh-be-tools'
+
+import { signIn, signUp } from './methods/authentication.js'
+import { subscribeCollection, unsubscribeCollection } from './methods/collectionActions.js'
+import { getCollectionPage } from './methods/collectionPage.js'
+import { subscribeCreator, unsubscribeCreator } from './methods/creatorActions.js'
+import { getCreatorPage } from './methods/creatorPage.js'
+import { subscribeProject, unsubscribeProject } from './methods/projectActions.js'
+import { getProjectFeed } from './methods/projectFeed.js'
+import { getProjectPage } from './methods/projectPage.js'
+import { searchCreatorAndProject } from './methods/searchCreatorAndProject.js'
+import { getSubscribedCreators, getSubscribedProjects } from './methods/subscriptions.js'
+import { getUpdateFeed } from './methods/updateFeed.js'
+import { getUser } from './methods/user.js'
+
+export const createClient = (baseUrl: string) => ({
+	signIn: (email: string, password: string, reqModifier: ProcessingMethods) => signIn(email, password, reqModifier, baseUrl),
+	signUp: (email: string, password: string, reqModifier: ProcessingMethods) => signUp(email, password, reqModifier, baseUrl),
+	getCollectionPage: (collectionId: string, reqModifier: ProcessingMethods) => getCollectionPage(collectionId, reqModifier, baseUrl),
+	subscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods) =>
+		subscribeCollection(collectionId, userId, reqModifier, baseUrl),
+	unsubscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods) =>
+		unsubscribeCollection(collectionId, userId, reqModifier, baseUrl),
+	getCreatorPage: (creatorId: string, reqModifier: ProcessingMethods) => getCreatorPage(creatorId, reqModifier, baseUrl),
+	subscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods) => subscribeCreator(creatorId, userId, reqModifier, baseUrl),
+	unsubscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods) =>
+		unsubscribeCreator(creatorId, userId, reqModifier, baseUrl),
+	getProjectPage: (projectId: string, reqModifier: ProcessingMethods) => getProjectPage(projectId, reqModifier, baseUrl),
+	subscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods) => subscribeProject(projectId, userId, reqModifier, baseUrl),
+	unsubscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods) =>
+		unsubscribeProject(projectId, userId, reqModifier, baseUrl),
+	getProjectFeed: (query: GetProjectFeedDef.Query, reqModifier: ProcessingMethods) => getProjectFeed(query, reqModifier, baseUrl),
+	getUpdateFeed: (query: GetUpdateFeedDef.Query, reqModifier: ProcessingMethods) => getUpdateFeed(query, reqModifier, baseUrl),
+	searchCreatorAndProject: (query: SearchCreatorProjectDef.Query, reqModifier: ProcessingMethods) =>
+		searchCreatorAndProject(query, reqModifier, baseUrl),
+	getSubscribedCreators: (userId: string, reqModifier: ProcessingMethods) => getSubscribedCreators(userId, reqModifier, baseUrl),
+	getSubscribedProjects: (userId: string, reqModifier: ProcessingMethods) => getSubscribedProjects(userId, reqModifier, baseUrl),
+	getUser: (userId: string, reqModifier: ProcessingMethods) => getUser(userId, reqModifier, baseUrl),
+})
+
+export type BffClient = ReturnType<typeof createClient>

package/dist/createClient.d.ts

@@ -0,0 +1,221 @@
+import { GetProjectFeedDef, GetUpdateFeedDef, SearchCreatorProjectDef } from '@jh-tech/bff-update-feed-app-shared';
+import { ProcessingMethods } from 'jh-be-tools';
+export declare const createClient: (baseUrl: string) => {
+    signIn: (email: string, password: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            userId: string;
+        };
+    }>;
+    signUp: (email: string, password: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            accessToken: string;
+            userId: string;
+        };
+    }>;
+    getCollectionPage: (collectionId: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            items: {
+                collectionId: string;
+                createdAt: string;
+                title: string;
+                type: "movie" | "album" | "single" | "game" | "book" | "tv show" | "collection";
+                projectId?: string | undefined;
+                subCollectionId?: string | undefined;
+            }[];
+            collection: {
+                id: string;
+                name: string;
+                createdAt: string;
+                updatedAt: string;
+            };
+        };
+    }>;
+    subscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods) => Promise<import("@jh-tech/bff-update-feed-app-shared/dist/route-definitions/collection.subscribe.js").Response>;
+    unsubscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods) => Promise<import("@jh-tech/bff-update-feed-app-shared/dist/route-definitions/collection.unsubscribe.js").Response>;
+    getCreatorPage: (creatorId: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            projects: {
+                id: string;
+                title: string;
+                type: "movie" | "album" | "single" | "game" | "book" | "tv show";
+                createdAt: string;
+                updatedAt: string;
+                description?: string | undefined;
+                releaseDate?: string | undefined;
+            }[];
+            creator: {
+                id: string;
+                name: string;
+                primaryRole: "studio" | "director" | "writer" | "actor" | "band" | "author" | "publisher" | "developer";
+                createdAt: string;
+                updatedAt: string;
+                description?: string | undefined;
+            };
+        };
+    }>;
+    subscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods) => Promise<import("@jh-tech/bff-update-feed-app-shared/dist/route-definitions/creator.subscribe.js").Response>;
+    unsubscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods) => Promise<import("@jh-tech/bff-update-feed-app-shared/dist/route-definitions/creator.unsubscribe.js").Response>;
+    getProjectPage: (projectId: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            updates: {
+                id: string;
+                title: string;
+                links: string[];
+                projectId: string;
+                publishedAt: string;
+                createdAt: string;
+            }[];
+            project: {
+                id: string;
+                title: string;
+                type: "movie" | "album" | "single" | "game" | "book" | "tv show";
+                createdAt: string;
+                updatedAt: string;
+                description?: string | undefined;
+                releaseDate?: string | undefined;
+            };
+            creators: {
+                id: string;
+                name: string;
+                role: "studio" | "director" | "writer" | "actor" | "band" | "author" | "publisher" | "developer";
+                primary: boolean;
+            }[];
+        };
+    }>;
+    subscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods) => Promise<import("@jh-tech/bff-update-feed-app-shared/dist/route-definitions/project.subscribe.js").Response>;
+    unsubscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods) => Promise<import("@jh-tech/bff-update-feed-app-shared/dist/route-definitions/project.unsubscribe.js").Response>;
+    getProjectFeed: (query: GetProjectFeedDef.Query, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            id: string;
+            type: "project";
+            title: string;
+            projectType: "movie" | "album" | "single" | "game" | "book" | "tv show";
+            primaryCreators: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            subscribedCreators: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            collections: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            createdAt: string;
+        }[];
+        meta?: {
+            cursor?: string | undefined;
+        } | undefined;
+    }>;
+    getUpdateFeed: (query: GetUpdateFeedDef.Query, reqModifier: ProcessingMethods) => Promise<{
+        data: ({
+            id: string;
+            type: "update";
+            title: string;
+            links: string[];
+            projectType: "movie" | "album" | "single" | "game" | "book" | "tv show";
+            project: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            };
+            primaryCreators: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            subscribedCreators: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            createdAt: string;
+        } | {
+            id: string;
+            type: "project";
+            title: string;
+            projectType: "movie" | "album" | "single" | "game" | "book" | "tv show";
+            primaryCreators: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            subscribedCreators: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            collections: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            }[];
+            createdAt: string;
+        } | {
+            id: string;
+            type: "collection";
+            name: string;
+            collection: {
+                id: string;
+                name: string;
+                type: "collection" | "creator" | "project";
+            };
+            createdAt: string;
+        })[];
+        meta?: {
+            cursor?: string | undefined;
+        } | undefined;
+    }>;
+    searchCreatorAndProject: (query: SearchCreatorProjectDef.Query, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            name: string;
+            creatorId?: string | undefined;
+            projectId?: string | undefined;
+            collectionId?: string | undefined;
+            projectType?: "movie" | "album" | "single" | "game" | "book" | "tv show" | undefined;
+            creatorRole?: "studio" | "director" | "writer" | "actor" | "band" | "author" | "publisher" | "developer" | undefined;
+        }[];
+        meta?: {
+            cursor?: string | undefined;
+        } | undefined;
+    }>;
+    getSubscribedCreators: (userId: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            creators: {
+                id: string;
+                name: string;
+                primaryRole: "studio" | "director" | "writer" | "actor" | "band" | "author" | "publisher" | "developer";
+                createdAt: string;
+                updatedAt: string;
+                description?: string | undefined;
+            }[];
+        };
+    }>;
+    getSubscribedProjects: (userId: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            projects: {
+                id: string;
+                title: string;
+                type: "movie" | "album" | "single" | "game" | "book" | "tv show";
+                createdAt: string;
+                updatedAt: string;
+                description?: string | undefined;
+                releaseDate?: string | undefined;
+            }[];
+        };
+    }>;
+    getUser: (userId: string, reqModifier: ProcessingMethods) => Promise<{
+        data: {
+            subscriptions: {
+                projectIds: string[];
+                creatorIds: string[];
+                collectionIds: string[];
+            };
+        };
+    }>;
+};
+export type BffClient = ReturnType<typeof createClient>;

package/dist/createClient.js

@@ -0,0 +1,31 @@
+import { signIn, signUp } from './methods/authentication.js';
+import { subscribeCollection, unsubscribeCollection } from './methods/collectionActions.js';
+import { getCollectionPage } from './methods/collectionPage.js';
+import { subscribeCreator, unsubscribeCreator } from './methods/creatorActions.js';
+import { getCreatorPage } from './methods/creatorPage.js';
+import { subscribeProject, unsubscribeProject } from './methods/projectActions.js';
+import { getProjectFeed } from './methods/projectFeed.js';
+import { getProjectPage } from './methods/projectPage.js';
+import { searchCreatorAndProject } from './methods/searchCreatorAndProject.js';
+import { getSubscribedCreators, getSubscribedProjects } from './methods/subscriptions.js';
+import { getUpdateFeed } from './methods/updateFeed.js';
+import { getUser } from './methods/user.js';
+export const createClient = (baseUrl) => ({
+    signIn: (email, password, reqModifier) => signIn(email, password, reqModifier, baseUrl),
+    signUp: (email, password, reqModifier) => signUp(email, password, reqModifier, baseUrl),
+    getCollectionPage: (collectionId, reqModifier) => getCollectionPage(collectionId, reqModifier, baseUrl),
+    subscribeCollection: (collectionId, userId, reqModifier) => subscribeCollection(collectionId, userId, reqModifier, baseUrl),
+    unsubscribeCollection: (collectionId, userId, reqModifier) => unsubscribeCollection(collectionId, userId, reqModifier, baseUrl),
+    getCreatorPage: (creatorId, reqModifier) => getCreatorPage(creatorId, reqModifier, baseUrl),
+    subscribeCreator: (creatorId, userId, reqModifier) => subscribeCreator(creatorId, userId, reqModifier, baseUrl),
+    unsubscribeCreator: (creatorId, userId, reqModifier) => unsubscribeCreator(creatorId, userId, reqModifier, baseUrl),
+    getProjectPage: (projectId, reqModifier) => getProjectPage(projectId, reqModifier, baseUrl),
+    subscribeProject: (projectId, userId, reqModifier) => subscribeProject(projectId, userId, reqModifier, baseUrl),
+    unsubscribeProject: (projectId, userId, reqModifier) => unsubscribeProject(projectId, userId, reqModifier, baseUrl),
+    getProjectFeed: (query, reqModifier) => getProjectFeed(query, reqModifier, baseUrl),
+    getUpdateFeed: (query, reqModifier) => getUpdateFeed(query, reqModifier, baseUrl),
+    searchCreatorAndProject: (query, reqModifier) => searchCreatorAndProject(query, reqModifier, baseUrl),
+    getSubscribedCreators: (userId, reqModifier) => getSubscribedCreators(userId, reqModifier, baseUrl),
+    getSubscribedProjects: (userId, reqModifier) => getSubscribedProjects(userId, reqModifier, baseUrl),
+    getUser: (userId, reqModifier) => getUser(userId, reqModifier, baseUrl),
+});

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export * from './methods/index.js';
+export { createClient } from './createClient.js';
+export type { BffClient } from './createClient.js';
 export * from '@jh-tech/bff-update-feed-app-shared';

package/dist/index.js

@@ -1,2 +1,2 @@
-export * from './methods/index.js';
+export { createClient } from './createClient.js';
 export * from '@jh-tech/bff-update-feed-app-shared';

package/dist/methods/authentication.d.ts

@@ -1,4 +1,4 @@
 import { AuthSignInDef, AuthSignUpDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const signIn: (email: string, password: string, reqModifier: ProcessingMethods) => Promise<AuthSignInDef.Response>;
-export declare const signUp: (email: string, password: string, reqModifier: ProcessingMethods) => Promise<AuthSignUpDef.Response>;
+export declare const signIn: (email: string, password: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<AuthSignInDef.Response>;
+export declare const signUp: (email: string, password: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<AuthSignUpDef.Response>;

package/dist/methods/authentication.js

@@ -1,7 +1,7 @@
 import { AuthSignInDef, AuthSignUpDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const signIn = async (email, password, reqModifier) => {
+export const signIn = async (email, password, reqModifier, baseUrl) => {
     const queryData = {
         body: {
             data: {
@@ -16,12 +16,12 @@ export const signIn = async (email, password, reqModifier) => {
     const definition = AuthSignInDef.definition;
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);
 };
-export const signUp = async (email, password, reqModifier) => {
+export const signUp = async (email, password, reqModifier, baseUrl) => {
     const queryData = {
         body: {
             data: {
@@ -33,7 +33,7 @@ export const signUp = async (email, password, reqModifier) => {
     const definition = AuthSignUpDef.definition;
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/collectionActions.d.ts

@@ -1,4 +1,4 @@
 import { CollectionSubscribeDef, CollectionUnsubscribeDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const subscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods) => Promise<CollectionSubscribeDef.Response>;
-export declare const unsubscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods) => Promise<CollectionUnsubscribeDef.Response>;
+export declare const subscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<CollectionSubscribeDef.Response>;
+export declare const unsubscribeCollection: (collectionId: string, userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<CollectionUnsubscribeDef.Response>;

package/dist/methods/collectionActions.js

@@ -1,7 +1,7 @@
 import { CollectionSubscribeDef, CollectionUnsubscribeDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const subscribeCollection = async (collectionId, userId, reqModifier) => {
+export const subscribeCollection = async (collectionId, userId, reqModifier, baseUrl) => {
     const definition = CollectionSubscribeDef.definition;
     const queryData = {
         query: { userId },
@@ -9,12 +9,12 @@ export const subscribeCollection = async (collectionId, userId, reqModifier) =>
     };
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);
 };
-export const unsubscribeCollection = async (collectionId, userId, reqModifier) => {
+export const unsubscribeCollection = async (collectionId, userId, reqModifier, baseUrl) => {
     const definition = CollectionUnsubscribeDef.definition;
     const queryData = {
         query: { userId },
@@ -22,7 +22,7 @@ export const unsubscribeCollection = async (collectionId, userId, reqModifier) =
     };
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/collectionPage.d.ts

@@ -1,3 +1,3 @@
 import { GetCollectionPageDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const getCollectionPage: (collectionId: string, reqModifier: ProcessingMethods) => Promise<GetCollectionPageDef.Response>;
+export declare const getCollectionPage: (collectionId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<GetCollectionPageDef.Response>;

package/dist/methods/collectionPage.js

@@ -1,14 +1,14 @@
 import { GetCollectionPageDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const getCollectionPage = async (collectionId, reqModifier) => {
+export const getCollectionPage = async (collectionId, reqModifier, baseUrl) => {
     const queryData = {
         params: { collectionId },
     };
     const definition = GetCollectionPageDef.definition;
     return await request({
         queryData: { ...queryData },
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/creatorActions.d.ts

@@ -1,4 +1,4 @@
 import { CreatorSubscribeDef, CreatorUnsubscribeDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const subscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods) => Promise<CreatorSubscribeDef.Response>;
-export declare const unsubscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods) => Promise<CreatorUnsubscribeDef.Response>;
+export declare const subscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<CreatorSubscribeDef.Response>;
+export declare const unsubscribeCreator: (creatorId: string, userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<CreatorUnsubscribeDef.Response>;

package/dist/methods/creatorActions.js

@@ -1,7 +1,7 @@
 import { CreatorSubscribeDef, CreatorUnsubscribeDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const subscribeCreator = async (creatorId, userId, reqModifier) => {
+export const subscribeCreator = async (creatorId, userId, reqModifier, baseUrl) => {
     const definition = CreatorSubscribeDef.definition;
     const queryData = {
         query: { userId },
@@ -9,12 +9,12 @@ export const subscribeCreator = async (creatorId, userId, reqModifier) => {
     };
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);
 };
-export const unsubscribeCreator = async (creatorId, userId, reqModifier) => {
+export const unsubscribeCreator = async (creatorId, userId, reqModifier, baseUrl) => {
     const definition = CreatorUnsubscribeDef.definition;
     const queryData = {
         query: { userId },
@@ -22,7 +22,7 @@ export const unsubscribeCreator = async (creatorId, userId, reqModifier) => {
     };
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/creatorPage.d.ts

@@ -1,3 +1,3 @@
 import { GetCreatorPageDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const getCreatorPage: (creatorId: string, reqModifier: ProcessingMethods) => Promise<GetCreatorPageDef.Response>;
+export declare const getCreatorPage: (creatorId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<GetCreatorPageDef.Response>;

package/dist/methods/creatorPage.js

@@ -1,14 +1,14 @@
 import { GetCreatorPageDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const getCreatorPage = async (creatorId, reqModifier) => {
+export const getCreatorPage = async (creatorId, reqModifier, baseUrl) => {
     const queryData = {
         params: { creatorId },
     };
     const definition = GetCreatorPageDef.definition;
     return await request({
         queryData: { ...queryData },
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/projectActions.d.ts

@@ -1,4 +1,4 @@
 import { ProjectSubscribeDef, ProjectUnsubscribeDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const subscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods) => Promise<ProjectSubscribeDef.Response>;
-export declare const unsubscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods) => Promise<ProjectUnsubscribeDef.Response>;
+export declare const subscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<ProjectSubscribeDef.Response>;
+export declare const unsubscribeProject: (projectId: string, userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<ProjectUnsubscribeDef.Response>;

package/dist/methods/projectActions.js

@@ -1,7 +1,7 @@
 import { ProjectSubscribeDef, ProjectUnsubscribeDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const subscribeProject = async (projectId, userId, reqModifier) => {
+export const subscribeProject = async (projectId, userId, reqModifier, baseUrl) => {
     const definition = ProjectSubscribeDef.definition;
     const queryData = {
         query: { userId },
@@ -9,12 +9,12 @@ export const subscribeProject = async (projectId, userId, reqModifier) => {
     };
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);
 };
-export const unsubscribeProject = async (projectId, userId, reqModifier) => {
+export const unsubscribeProject = async (projectId, userId, reqModifier, baseUrl) => {
     const definition = ProjectUnsubscribeDef.definition;
     const queryData = {
         query: { userId },
@@ -22,7 +22,7 @@ export const unsubscribeProject = async (projectId, userId, reqModifier) => {
     };
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/projectFeed.d.ts

@@ -1,3 +1,3 @@
 import { GetProjectFeedDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const getProjectFeed: (query: GetProjectFeedDef.Query, reqModifier: ProcessingMethods) => Promise<GetProjectFeedDef.Response>;
+export declare const getProjectFeed: (query: GetProjectFeedDef.Query, reqModifier: ProcessingMethods, baseUrl: string) => Promise<GetProjectFeedDef.Response>;

package/dist/methods/projectFeed.js

@@ -1,14 +1,14 @@
 import { GetProjectFeedDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const getProjectFeed = async (query, reqModifier) => {
+export const getProjectFeed = async (query, reqModifier, baseUrl) => {
     const queryData = {
         query,
     };
     const definition = GetProjectFeedDef.definition;
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/projectPage.d.ts

@@ -1,3 +1,3 @@
 import { GetProjectPageDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const getProjectPage: (projectId: string, reqModifier: ProcessingMethods) => Promise<GetProjectPageDef.Response>;
+export declare const getProjectPage: (projectId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<GetProjectPageDef.Response>;

package/dist/methods/projectPage.js

@@ -1,12 +1,12 @@
 import { GetProjectPageDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const getProjectPage = async (projectId, reqModifier) => {
+export const getProjectPage = async (projectId, reqModifier, baseUrl) => {
     const queryData = { params: { projectId } };
     const definition = GetProjectPageDef.definition;
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/searchCreatorAndProject.d.ts

@@ -1,3 +1,3 @@
 import { SearchCreatorProjectDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const searchCreatorAndProject: (search: string, reqModifier: ProcessingMethods) => Promise<SearchCreatorProjectDef.Response>;
+export declare const searchCreatorAndProject: (query: SearchCreatorProjectDef.Query, reqModifier: ProcessingMethods, baseUrl: string) => Promise<SearchCreatorProjectDef.Response>;

package/dist/methods/searchCreatorAndProject.js

@@ -1,12 +1,12 @@
 import { SearchCreatorProjectDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const searchCreatorAndProject = async (search, reqModifier) => {
-    const queryData = { query: { search } };
+export const searchCreatorAndProject = async (query, reqModifier, baseUrl) => {
+    const queryData = { query };
     const definition = SearchCreatorProjectDef.definition;
     return await request({
         queryData,
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/subscriptions.d.ts

@@ -1,4 +1,4 @@
 import { GetSubscribedCreatorsDef, GetSubscribedProjectsDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const getSubscribedCreators: (userId: string, reqModifier: ProcessingMethods) => Promise<GetSubscribedCreatorsDef.Response>;
-export declare const getSubscribedProjects: (userId: string, reqModifier: ProcessingMethods) => Promise<GetSubscribedProjectsDef.Response>;
+export declare const getSubscribedCreators: (userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<GetSubscribedCreatorsDef.Response>;
+export declare const getSubscribedProjects: (userId: string, reqModifier: ProcessingMethods, baseUrl: string) => Promise<GetSubscribedProjectsDef.Response>;

package/dist/methods/subscriptions.js

@@ -1,26 +1,26 @@
 import { GetSubscribedCreatorsDef, GetSubscribedProjectsDef } from '@jh-tech/bff-update-feed-app-shared';
 import { request } from 'jh-be-tools';
 import { serviceName } from './const.js';
-export const getSubscribedCreators = async (userId, reqModifier) => {
+export const getSubscribedCreators = async (userId, reqModifier, baseUrl) => {
     const queryData = {
         query: { userId },
     };
     const definition = GetSubscribedCreatorsDef.definition;
     return await request({
         queryData: { ...queryData },
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);
 };
-export const getSubscribedProjects = async (userId, reqModifier) => {
+export const getSubscribedProjects = async (userId, reqModifier, baseUrl) => {
     const queryData = {
         query: { userId },
     };
     const definition = GetSubscribedProjectsDef.definition;
     return await request({
         queryData: { ...queryData },
-        baseUrl: `${process.env.BFF_UPDATE_FEED}`,
+        baseUrl,
         serviceName,
         definition,
     }, reqModifier);

package/dist/methods/updateFeed.d.ts

@@ -1,3 +1,3 @@
 import { GetUpdateFeedDef } from '@jh-tech/bff-update-feed-app-shared';
 import { ProcessingMethods } from 'jh-be-tools';
-export declare const getUpdateFeed: (query: GetUpdateFeedDef.Query, reqModifier: ProcessingMethods) => Promise<GetUpdateFeedDef.Response>;
+export declare const getUpdateFeed: (query: GetUpdateFeedDef.Query, reqModifier: ProcessingMethods, baseUrl: string) => Promise<GetUpdateFeedDef.Response>;