@comergehq/studio 0.1.2 → 0.1.3

package/src/data/comments/likes/types.ts

@@ -0,0 +1,47 @@
+export type AppCommentLike = {
+  id: string;
+  appId: string;
+  commentId: string;
+  userId: string;
+  source: string | null;
+  context: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type ListAppCommentLikesQuery = {
+  page?: number;
+  pageSize?: number;
+  userId?: string;
+};
+
+export type CreateAppCommentLikeInput = {
+  source?: string;
+  context?: Record<string, unknown>;
+};
+
+export type AppCommentLikeStats = {
+  total?: number;
+};
+
+export type AppCommentLikeList = {
+  items: AppCommentLike[];
+  pageInfo: {
+    page: number;
+    pageSize: number;
+    total: number;
+    hasMore: boolean;
+  };
+  stats?: AppCommentLikeStats;
+};
+
+export type AppCommentLikeMutationResult = {
+  like: AppCommentLike;
+  stats?: AppCommentLikeStats;
+};
+
+export type AppCommentLikeStatsResult = {
+  stats?: AppCommentLikeStats;
+};
+
+

package/src/data/comments/remote.ts

@@ -0,0 +1,71 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type {
+  AppComment,
+  AppCommentList,
+  CreateAppCommentInput,
+  ListAppCommentsQuery,
+  UpdateAppCommentInput,
+} from './types';
+
+export interface AppCommentsRemoteDataSource {
+  list(appId: string, query?: ListAppCommentsQuery): Promise<ServiceResponse<AppCommentList>>;
+  getById(appId: string, commentId: string): Promise<ServiceResponse<AppComment>>;
+  create(appId: string, payload: CreateAppCommentInput): Promise<ServiceResponse<AppComment>>;
+  update(
+    appId: string,
+    commentId: string,
+    payload: UpdateAppCommentInput
+  ): Promise<ServiceResponse<AppComment>>;
+  remove(appId: string, commentId: string): Promise<ServiceResponse<AppComment>>;
+}
+
+class AppCommentsRemoteDataSourceImpl extends BaseRemote implements AppCommentsRemoteDataSource {
+  async list(appId: string, query?: ListAppCommentsQuery): Promise<ServiceResponse<AppCommentList>> {
+    const params = query ? { ...query } : undefined;
+    const { data } = await api.get<ServiceResponse<AppCommentList>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments`,
+      { params }
+    );
+    return data;
+  }
+
+  async getById(appId: string, commentId: string): Promise<ServiceResponse<AppComment>> {
+    const { data } = await api.get<ServiceResponse<AppComment>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments/${encodeURIComponent(commentId)}`
+    );
+    return data;
+  }
+
+  async create(appId: string, payload: CreateAppCommentInput): Promise<ServiceResponse<AppComment>> {
+    const { data } = await api.post<ServiceResponse<AppComment>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments`,
+      payload
+    );
+    return data;
+  }
+
+  async update(
+    appId: string,
+    commentId: string,
+    payload: UpdateAppCommentInput
+  ): Promise<ServiceResponse<AppComment>> {
+    const { data } = await api.patch<ServiceResponse<AppComment>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments/${encodeURIComponent(commentId)}`,
+      payload
+    );
+    return data;
+  }
+
+  async remove(appId: string, commentId: string): Promise<ServiceResponse<AppComment>> {
+    const { data } = await api.delete<ServiceResponse<AppComment>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments/${encodeURIComponent(commentId)}`
+    );
+    return data;
+  }
+}
+
+export const appCommentsRemoteDataSource: AppCommentsRemoteDataSource = new AppCommentsRemoteDataSourceImpl();
+
+

package/src/data/comments/repository.ts

@@ -0,0 +1,53 @@
+import type { AppCommentsRemoteDataSource } from './remote';
+import { appCommentsRemoteDataSource } from './remote';
+import type {
+  AppComment,
+  AppCommentList,
+  CreateAppCommentInput,
+  ListAppCommentsQuery,
+  UpdateAppCommentInput,
+} from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface AppCommentsRepository {
+  list(appId: string, query?: ListAppCommentsQuery): Promise<AppCommentList>;
+  getById(appId: string, commentId: string): Promise<AppComment>;
+  create(appId: string, payload: CreateAppCommentInput): Promise<AppComment>;
+  update(appId: string, commentId: string, payload: UpdateAppCommentInput): Promise<AppComment>;
+  remove(appId: string, commentId: string): Promise<AppComment>;
+}
+
+class AppCommentsRepositoryImpl extends BaseRepository implements AppCommentsRepository {
+  constructor(private readonly remote: AppCommentsRemoteDataSource) {
+    super();
+  }
+
+  async list(appId: string, query?: ListAppCommentsQuery): Promise<AppCommentList> {
+    const res = await this.remote.list(appId, query);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getById(appId: string, commentId: string): Promise<AppComment> {
+    const res = await this.remote.getById(appId, commentId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async create(appId: string, payload: CreateAppCommentInput): Promise<AppComment> {
+    const res = await this.remote.create(appId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async update(appId: string, commentId: string, payload: UpdateAppCommentInput): Promise<AppComment> {
+    const res = await this.remote.update(appId, commentId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async remove(appId: string, commentId: string): Promise<AppComment> {
+    const res = await this.remote.remove(appId, commentId);
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const appCommentsRepository: AppCommentsRepository = new AppCommentsRepositoryImpl(appCommentsRemoteDataSource);
+
+

package/src/data/comments/types.ts

@@ -0,0 +1,60 @@
+export type CommentType = 'general' | 'review' | 'bug' | 'question' | 'idea' | 'other';
+
+export type CommentMediaItem = {
+  id?: string;
+  url: string;
+  thumbnailUrl?: string;
+  type: 'image' | 'video' | 'file' | 'other';
+  alt?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type AppComment = {
+  id: string;
+  appId: string;
+  authorId: string;
+  commentType: CommentType;
+  description: string | null;
+  body: string | null;
+  bodyRich: Record<string, unknown> | null;
+  media: CommentMediaItem[];
+  metadata: Record<string, unknown>;
+  parentCommentId: string | null;
+  isDeleted: boolean;
+  deletedAt: string | null;
+  deletedBy: string | null;
+  lastEditedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type CreateAppCommentInput = {
+  commentType?: CommentType;
+  description?: string | null;
+  body?: string | null;
+  bodyRich?: Record<string, unknown> | null;
+  media?: CommentMediaItem[];
+  metadata?: Record<string, unknown>;
+  parentCommentId?: string | null;
+};
+
+export type UpdateAppCommentInput = Partial<CreateAppCommentInput>;
+
+export type ListAppCommentsQuery = {
+  page?: number;
+  pageSize?: number;
+  parentCommentId?: string | null;
+  includeDeleted?: boolean;
+};
+
+export type AppCommentList = {
+  items: AppComment[];
+  pageInfo: {
+    page: number;
+    pageSize: number;
+    total: number;
+    hasMore: boolean;
+  };
+};
+
+

package/src/data/github/remote.ts

@@ -0,0 +1,23 @@
+import { api } from '../../core/services/http';
+import { BaseRemote } from '../base-remote';
+import type { ServiceResponse } from '../types';
+import type { GithubOAuthStart, GithubReposResponse } from './types';
+
+export interface GithubRemoteDataSource {
+  getOAuthUrl(): Promise<ServiceResponse<GithubOAuthStart>>;
+  listRepos(): Promise<ServiceResponse<GithubReposResponse>>;
+}
+
+class GithubRemoteDataSourceImpl extends BaseRemote implements GithubRemoteDataSource {
+  async getOAuthUrl(): Promise<ServiceResponse<GithubOAuthStart>> {
+    const { data } = await api.get<ServiceResponse<GithubOAuthStart>>('/v1/github/oauth/start');
+    return data;
+  }
+
+  async listRepos(): Promise<ServiceResponse<GithubReposResponse>> {
+    const { data } = await api.get<ServiceResponse<GithubReposResponse>>('/v1/github/repos');
+    return data;
+  }
+}
+
+export const githubRemoteDataSource: GithubRemoteDataSource = new GithubRemoteDataSourceImpl();

package/src/data/github/repository.ts

@@ -0,0 +1,35 @@
+import { BaseRepository } from '../../data/base-repository';
+import type { GithubRemoteDataSource } from './remote';
+import { githubRemoteDataSource } from './remote';
+import type { GithubOAuthStart, GithubRepo, GithubReposResponse } from './types';
+
+export interface GithubRepository {
+  getOAuthUrl(): Promise<GithubOAuthStart>;
+  listRepos(): Promise<GithubRepo[]>;
+}
+
+class GithubRepositoryImpl extends BaseRepository implements GithubRepository {
+  constructor(private readonly remote: GithubRemoteDataSource) {
+    super();
+  }
+
+  async getOAuthUrl(): Promise<GithubOAuthStart> {
+    const res = await this.remote.getOAuthUrl();
+    return this.unwrapOrThrow(res);
+  }
+
+  async listRepos(): Promise<GithubRepo[]> {
+    const res = await this.remote.listRepos();
+    const payload = this.unwrapOrThrow(res) as GithubReposResponse;
+    return (payload.repositories || []).map((repo) => ({
+      id: repo.id,
+      name: repo.name,
+      fullName: repo.full_name,
+      private: repo.private,
+      defaultBranch: repo.default_branch,
+      ownerLogin: repo.owner?.login ?? null,
+    }));
+  }
+}
+
+export const githubRepository: GithubRepository = new GithubRepositoryImpl(githubRemoteDataSource);

package/src/data/github/types.ts

@@ -0,0 +1,23 @@
+export type GithubOAuthStart = {
+  url: string;
+};
+
+export type GithubRepo = {
+  id: number;
+  name: string;
+  fullName: string;
+  private: boolean;
+  defaultBranch?: string;
+  ownerLogin?: string | null;
+};
+
+export type GithubReposResponse = {
+  repositories: {
+    id: number;
+    name: string;
+    full_name: string;
+    private: boolean;
+    default_branch?: string;
+    owner?: { login?: string | null };
+  }[];
+};

package/src/data/home/remote.ts

@@ -0,0 +1,24 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type { HomeSection, HomeSummary } from './types';
+
+export interface HomeRemoteDataSource {
+  getSummary(): Promise<ServiceResponse<HomeSummary>>;
+  getSections(): Promise<ServiceResponse<HomeSection[]>>;
+}
+
+class HomeRemoteDataSourceImpl extends BaseRemote implements HomeRemoteDataSource {
+  async getSummary(): Promise<ServiceResponse<HomeSummary>> {
+    const { data } = await api.get<ServiceResponse<HomeSummary>>('/v1/home/summary');
+    return data;
+  }
+
+  async getSections(): Promise<ServiceResponse<HomeSection[]>> {
+    const { data } = await api.get<ServiceResponse<HomeSection[]>>('/v1/home/sections');
+    return data;
+  }
+}
+
+export const homeRemoteDataSource: HomeRemoteDataSource = new HomeRemoteDataSourceImpl();
+

package/src/data/home/repository.ts

@@ -0,0 +1,28 @@
+import type { HomeRemoteDataSource } from './remote';
+import { homeRemoteDataSource } from './remote';
+import type { HomeSection, HomeSummary } from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface HomeRepository {
+  getSummary(): Promise<HomeSummary>;
+  getSections(): Promise<HomeSection[]>;
+}
+
+class HomeRepositoryImpl extends BaseRepository implements HomeRepository {
+  constructor(private readonly remote: HomeRemoteDataSource) {
+    super();
+  }
+
+  async getSummary(): Promise<HomeSummary> {
+    const res = await this.remote.getSummary();
+    return this.unwrapOrThrow(res);
+  }
+
+  async getSections(): Promise<HomeSection[]> {
+    const res = await this.remote.getSections();
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const homeRepository: HomeRepository = new HomeRepositoryImpl(homeRemoteDataSource);
+

package/src/data/home/types.ts

@@ -0,0 +1,70 @@
+export type HomeProfile = {
+  name: string | null;
+  email: string | null;
+  avatar: string | null;
+};
+
+export type HomeNotificationGroup = {
+  appId: string;
+  appName: string;
+  threadId: string | null;
+  count: number;
+};
+
+export type HomeNotifications = {
+  totalCount: number;
+  groups: HomeNotificationGroup[];
+};
+
+export type HomeSummary = {
+  profile: HomeProfile;
+  notifications: HomeNotifications;
+};
+
+export type HomeSectionAppStats = {
+  totalDownloads: number;
+  totalDownloadUsers: number;
+  totalLikes: number;
+  totalComments: number;
+  totalRatings: number;
+  averageRating: number | null;
+  totalMergeRequests: number;
+  totalForks: number;
+};
+
+export type HomeSectionAppDetails = {
+  id: string;
+  name: string;
+  description: string | null;
+  isLiked?: boolean;
+  url: string | null;
+  platform: string | null;
+  isPublic: boolean;
+  status: string | null;
+  lastUpdatedAt: string;
+  stats: HomeSectionAppStats | null;
+};
+
+export type HomeSectionApp = {
+  id: string;
+  appId: string;
+  sortOrder: number;
+  createdAt: string;
+  updatedAt: string;
+  app: HomeSectionAppDetails;
+};
+
+export type HomeSection = {
+  id: string;
+  title: string;
+  subtitle: string | null;
+  description: string | null;
+  layoutType: 'vertical_list' | 'horizontal_list' | 'grid' | 'carousel';
+  isPublished: boolean;
+  sortOrder: number;
+  metadata: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+  listOfApps: HomeSectionApp[];
+};
+

package/src/data/index.ts

@@ -0,0 +1,3 @@
+export * from '../core/services/supabase';
+
+

package/src/data/likes/remote.ts

@@ -0,0 +1,57 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type {
+  AppLikeList,
+  AppLikeMutationResult,
+  AppLikeStatsResult,
+  CreateAppLikeInput,
+  ListAppLikesQuery,
+} from './types';
+
+export interface AppLikesRemoteDataSource {
+  list(appId: string, query?: ListAppLikesQuery): Promise<ServiceResponse<AppLikeList>>;
+  create(appId: string, payload: CreateAppLikeInput): Promise<ServiceResponse<AppLikeMutationResult>>;
+  removeById(appId: string, likeId: string): Promise<ServiceResponse<AppLikeStatsResult>>;
+  removeMine(appId: string): Promise<ServiceResponse<AppLikeStatsResult>>;
+}
+
+class AppLikesRemoteDataSourceImpl extends BaseRemote implements AppLikesRemoteDataSource {
+  async list(appId: string, query?: ListAppLikesQuery): Promise<ServiceResponse<AppLikeList>> {
+    const params = query ? { ...query } : undefined;
+    const { data } = await api.get<ServiceResponse<AppLikeList>>(
+      `/v1/apps/${encodeURIComponent(appId)}/likes`,
+      { params }
+    );
+    return data;
+  }
+
+  async create(
+    appId: string,
+    payload: CreateAppLikeInput
+  ): Promise<ServiceResponse<AppLikeMutationResult>> {
+    const { data } = await api.post<ServiceResponse<AppLikeMutationResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/likes`,
+      payload
+    );
+    return data;
+  }
+
+  async removeById(appId: string, likeId: string): Promise<ServiceResponse<AppLikeStatsResult>> {
+    const { data } = await api.delete<ServiceResponse<AppLikeStatsResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/likes/${encodeURIComponent(likeId)}`
+    );
+    return data;
+  }
+
+  async removeMine(appId: string): Promise<ServiceResponse<AppLikeStatsResult>> {
+    const { data } = await api.delete<ServiceResponse<AppLikeStatsResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/likes/me`
+    );
+    return data;
+  }
+}
+
+export const appLikesRemoteDataSource: AppLikesRemoteDataSource = new AppLikesRemoteDataSourceImpl();
+
+

package/src/data/likes/repository.ts

@@ -0,0 +1,47 @@
+import type { AppLikesRemoteDataSource } from './remote';
+import { appLikesRemoteDataSource } from './remote';
+import type {
+  AppLikeList,
+  AppLikeMutationResult,
+  AppLikeStatsResult,
+  CreateAppLikeInput,
+  ListAppLikesQuery,
+} from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface AppLikesRepository {
+  list(appId: string, query?: ListAppLikesQuery): Promise<AppLikeList>;
+  create(appId: string, payload: CreateAppLikeInput): Promise<AppLikeMutationResult>;
+  removeById(appId: string, likeId: string): Promise<AppLikeStatsResult>;
+  removeMine(appId: string): Promise<AppLikeStatsResult>;
+}
+
+class AppLikesRepositoryImpl extends BaseRepository implements AppLikesRepository {
+  constructor(private readonly remote: AppLikesRemoteDataSource) {
+    super();
+  }
+
+  async list(appId: string, query?: ListAppLikesQuery): Promise<AppLikeList> {
+    const res = await this.remote.list(appId, query);
+    return this.unwrapOrThrow(res);
+  }
+
+  async create(appId: string, payload: CreateAppLikeInput): Promise<AppLikeMutationResult> {
+    const res = await this.remote.create(appId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async removeById(appId: string, likeId: string): Promise<AppLikeStatsResult> {
+    const res = await this.remote.removeById(appId, likeId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async removeMine(appId: string): Promise<AppLikeStatsResult> {
+    const res = await this.remote.removeMine(appId);
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const appLikesRepository: AppLikesRepository = new AppLikesRepositoryImpl(appLikesRemoteDataSource);
+
+

package/src/data/likes/types.ts

@@ -0,0 +1,46 @@
+export type AppLike = {
+  id: string;
+  appId: string;
+  userId: string;
+  source: string | null;
+  context: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type ListAppLikesQuery = {
+  page?: number;
+  pageSize?: number;
+  userId?: string;
+};
+
+export type CreateAppLikeInput = {
+  source?: string;
+  context?: Record<string, unknown>;
+};
+
+export type AppLikeStats = {
+  total?: number;
+};
+
+export type AppLikeList = {
+  items: AppLike[];
+  pageInfo: {
+    page: number;
+    pageSize: number;
+    total: number;
+    hasMore: boolean;
+  };
+  stats: AppLikeStats;
+};
+
+export type AppLikeMutationResult = {
+  like: AppLike;
+  stats?: AppLikeStats;
+};
+
+export type AppLikeStatsResult = {
+  stats?: AppLikeStats;
+};
+
+

package/src/data/me/remote.ts

@@ -0,0 +1,28 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type { MeProfile } from './types';
+
+export interface MeRemoteDataSource {
+  getMe(): Promise<ServiceResponse<MeProfile>>;
+  setExpoPushToken(expoPushToken: string): Promise<ServiceResponse<{ expoPushToken: string }>>;
+}
+
+class MeRemoteDataSourceImpl extends BaseRemote implements MeRemoteDataSource {
+  async getMe(): Promise<ServiceResponse<MeProfile>> {
+    const { data } = await api.get<ServiceResponse<MeProfile>>('/v1/me');
+    return data;
+  }
+
+  async setExpoPushToken(expoPushToken: string): Promise<ServiceResponse<{ expoPushToken: string }>> {
+    const { data } = await api.post<ServiceResponse<{ expoPushToken: string }>>(
+      '/v1/me/expo-push-token',
+      { expoPushToken }
+    );
+    return data;
+  }
+}
+
+export const meRemoteDataSource: MeRemoteDataSource = new MeRemoteDataSourceImpl();
+
+

package/src/data/me/repository.ts

@@ -0,0 +1,30 @@
+import type { MeRemoteDataSource } from './remote';
+import { meRemoteDataSource } from './remote';
+import type { MeProfile } from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface MeRepository {
+  getMe(): Promise<MeProfile>;
+  setExpoPushToken(expoPushToken: string): Promise<string>;
+}
+
+class MeRepositoryImpl extends BaseRepository implements MeRepository {
+  constructor(private readonly remote: MeRemoteDataSource) {
+    super();
+  }
+
+  async getMe(): Promise<MeProfile> {
+    const res = await this.remote.getMe();
+    return this.unwrapOrThrow(res);
+  }
+
+  async setExpoPushToken(expoPushToken: string): Promise<string> {
+    const res = await this.remote.setExpoPushToken(expoPushToken);
+    const out = this.unwrapOrThrow(res);
+    return out.expoPushToken;
+  }
+}
+
+export const meRepository: MeRepository = new MeRepositoryImpl(meRemoteDataSource);
+
+

package/src/data/me/types.ts

@@ -0,0 +1,14 @@
+export type MeProfile = {
+  id: string;
+  name: string | null;
+  email: string | null;
+  phone: string | null;
+  isVerified: boolean;
+  avatar: string | null;
+  organizationId: string | null;
+  createdAt: string;
+  updatedAt: string;
+  lastLoginAt: string | null;
+};
+
+