@comergehq/studio 0.1.1 → 0.1.3

package/src/data/apps/repository.ts

@@ -0,0 +1,185 @@
+import type {
+  App,
+  AppAnalyticsParams,
+  AppAnalyticsPoint,
+  AppInsights,
+  AppsSummary,
+  ForkAppRequest,
+  ImportGithubAppRequest,
+  ImportGithubAppResponse,
+  ListAppsSummaryParams,
+  ListLikedAppsParams,
+  ListPublicAppsParams,
+  LikedAppsList,
+} from './types';
+import { appsRemoteDataSource } from './remote';
+import type { AppsRemoteDataSource } from './remote';
+import { BaseRepository } from '../../data/base-repository';
+import { getSupabaseClient } from '../../core/services/supabase';
+
+type DbAppRow = {
+  id: string;
+  name: string;
+  description: string | null;
+  apple_app_store_category: string | null;
+  google_play_category: string | null;
+  pg_rating: string | null;
+  project_id: string;
+  platform: string | null;
+  is_public: boolean;
+  created_by: string;
+  status: App['status'];
+  status_error: string | null;
+  status_changed_at: string | null;
+  head_commit_id: string | null;
+  forked_from_commit_id: string | null;
+  forked_from_app_id: string | null;
+  thread_id: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+type AppSubscriptionHandlers = {
+  onInsert?: (app: App) => void;
+  onUpdate?: (app: App) => void;
+  onDelete?: (app: App) => void;
+};
+
+function mapDbAppRow(row: DbAppRow): App {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    appleAppStoreCategory: row.apple_app_store_category,
+    googlePlayCategory: row.google_play_category,
+    pgRating: row.pg_rating,
+    projectId: row.project_id,
+    platform: row.platform,
+    isPublic: row.is_public,
+    createdBy: row.created_by,
+    status: row.status,
+    statusError: row.status_error,
+    statusChangedAt: row.status_changed_at,
+    headCommitId: row.head_commit_id,
+    forkedFromCommitId: row.forked_from_commit_id,
+    forkedFromAppId: row.forked_from_app_id,
+    threadId: row.thread_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    insights: null,
+  };
+}
+
+export interface AppsRepository {
+  list(projectId?: string): Promise<App[]>;
+  listPublicOthers(params?: ListPublicAppsParams): Promise<App[]>;
+  getSummary(params?: ListAppsSummaryParams): Promise<AppsSummary>;
+  listLiked(params?: ListLikedAppsParams): Promise<LikedAppsList>;
+  getById(appId: string): Promise<App>;
+  fork(appId: string, payload: ForkAppRequest): Promise<App>;
+  getInsights(appId: string): Promise<AppInsights>;
+  getAnalytics(appId: string, params: AppAnalyticsParams): Promise<AppAnalyticsPoint[]>;
+  subscribeCreatedApps(userId: string, handlers: AppSubscriptionHandlers): () => void;
+  subscribeApp(appId: string, handlers: AppSubscriptionHandlers): () => void;
+  importFromGithub(payload: ImportGithubAppRequest): Promise<ImportGithubAppResponse>;
+}
+
+class AppsRepositoryImpl extends BaseRepository implements AppsRepository {
+  constructor(private readonly remote: AppsRemoteDataSource) {
+    super();
+  }
+
+  async list(projectId?: string): Promise<App[]> {
+    const res = await this.remote.list(projectId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async listPublicOthers(params?: ListPublicAppsParams): Promise<App[]> {
+    const res = await this.remote.listPublicOthers(params);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getSummary(params?: ListAppsSummaryParams): Promise<AppsSummary> {
+    const res = await this.remote.listSummary(params);
+    return this.unwrapOrThrow(res);
+  }
+
+  async listLiked(params?: ListLikedAppsParams): Promise<LikedAppsList> {
+    const res = await this.remote.listLiked(params);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getById(appId: string): Promise<App> {
+    const res = await this.remote.getById(appId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async fork(appId: string, payload: ForkAppRequest): Promise<App> {
+    const res = await this.remote.fork(appId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getInsights(appId: string): Promise<AppInsights> {
+    const res = await this.remote.getInsights(appId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getAnalytics(appId: string, params: AppAnalyticsParams): Promise<AppAnalyticsPoint[]> {
+    const res = await this.remote.getAnalytics(appId, params);
+    return this.unwrapOrThrow(res);
+  }
+
+  async importFromGithub(payload: ImportGithubAppRequest): Promise<ImportGithubAppResponse> {
+    const res = await this.remote.importFromGithub(payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  subscribeCreatedApps(userId: string, handlers: AppSubscriptionHandlers): () => void {
+    if (!userId) return () => {};
+    return this.subscribeToAppChannel(`apps:createdBy:${userId}`, `created_by=eq.${userId}`, handlers);
+  }
+
+  subscribeApp(appId: string, handlers: AppSubscriptionHandlers): () => void {
+    if (!appId) return () => {};
+    return this.subscribeToAppChannel(`apps:id:${appId}`, `id=eq.${appId}`, handlers);
+  }
+
+  private subscribeToAppChannel(channelKey: string, filter: string, handlers: AppSubscriptionHandlers): () => void {
+    const supabase = getSupabaseClient();
+    const channel = supabase
+      .channel(channelKey)
+      .on(
+        'postgres_changes',
+        { event: 'INSERT', schema: 'public', table: 'app', filter },
+        (payload) => {
+          console.log('[subscribeToAppChannel] onInsert', payload);
+          handlers.onInsert?.(mapDbAppRow(payload.new as DbAppRow));
+        }
+      )
+      .on(
+        'postgres_changes',
+        { event: 'UPDATE', schema: 'public', table: 'app', filter },
+        (payload) => {
+          console.log('[subscribeToAppChannel] onUpdate', payload);
+          handlers.onUpdate?.(mapDbAppRow(payload.new as DbAppRow));
+        }
+      )
+      .on(
+        'postgres_changes',
+        { event: 'DELETE', schema: 'public', table: 'app', filter },
+        (payload) => {
+          console.log('[subscribeToAppChannel] onDelete', payload);
+          handlers.onDelete?.(mapDbAppRow(payload.old as DbAppRow));
+        }
+      )
+      .subscribe();
+
+    return () => {
+      supabase.removeChannel(channel);
+    };
+  }
+}
+
+export const appsRepository: AppsRepository = new AppsRepositoryImpl(appsRemoteDataSource);
+
+

package/src/data/apps/types.ts

@@ -0,0 +1,206 @@
+export type AppInsightsSummary = {
+  totalDownloads: number;
+  totalDownloadUsers: number;
+  totalLikes: number;
+  totalComments: number;
+  totalRatings: number;
+  averageRating: number | null;
+  totalMergeRequests: number;
+  totalForks: number;
+};
+
+export type DownloadUserSummary = {
+  userId: string;
+  totalDownloads: number;
+  lastDownloadAt: string | null;
+};
+
+export type ForkEntry = {
+  appId: string;
+  userId: string;
+  createdAt: string;
+};
+
+export type MergeRequestEntry = {
+  id: string;
+  sourceAppId: string;
+  createdBy: string;
+  status: string;
+  createdAt: string;
+};
+
+export type LikeEntry = {
+  userId: string;
+  createdAt: string;
+};
+
+export type CommentEntry = {
+  id: string;
+  userId: string;
+  commentType: string;
+  createdAt: string;
+};
+
+export type RatingEntry = {
+  userId: string;
+  rating: number;
+  createdAt: string;
+};
+
+export type AppInsights = {
+  downloads: {
+    total: number;
+    uniqueUsers: number;
+    perUser: DownloadUserSummary[];
+  };
+  forks: {
+    total: number;
+    entries: ForkEntry[];
+  };
+  mergeRequests: {
+    total: number;
+    approved: number;
+    merged: number;
+    entries: MergeRequestEntry[];
+  };
+  likes: {
+    total: number;
+    entries: LikeEntry[];
+  };
+  comments: {
+    total: number;
+    entries: CommentEntry[];
+  };
+  ratings: {
+    total: number;
+    average: number | null;
+    entries: RatingEntry[];
+  };
+};
+
+export const APP_METRIC_TYPES = [
+  'downloads',
+  'likes',
+  'comments',
+  'forks',
+  'mergeRequests',
+  'mergeRequestApprovals',
+] as const;
+
+export type AppMetricType = (typeof APP_METRIC_TYPES)[number];
+
+export const APP_ANALYTIC_INTERVALS = ['day', 'hour'] as const;
+
+export type AppAnalyticsInterval = (typeof APP_ANALYTIC_INTERVALS)[number];
+
+export type AppAnalyticsParams = {
+  type: AppMetricType;
+  startDate: string;
+  endDate: string;
+  interval?: AppAnalyticsInterval;
+};
+
+export type AppAnalyticsPoint = {
+  date: string;
+  value: number;
+};
+
+export type App = {
+  id: string;
+  name: string;
+  description: string | null;
+  appleAppStoreCategory: string | null;
+  googlePlayCategory: string | null;
+  pgRating: string | null;
+  projectId: string;
+  platform: string | null;
+  isPublic: boolean;
+  isLiked?: boolean;
+  createdBy: string;
+  status: 'ready' | 'creating' | 'editing' | 'forking' | 'merging' | 'error' | 'archived';
+  statusError: string | null;
+  statusChangedAt: string | null;
+  headCommitId: string | null;
+  forkedFromCommitId: string | null;
+  forkedFromAppId: string | null;
+  threadId: string | null;
+  createdAt: string;
+  updatedAt: string;
+  insights?: AppInsightsSummary | null;
+};
+
+export type AppStatus = App['status'];
+
+export type ForkAppRequest = {
+  name?: string;
+  platform?: string;
+  forkedFromCommitId?: string;
+};
+
+export type ImportGithubAppRequest = {
+  repoFullName: string;
+  branch?: string;
+  path?: string;
+  appName?: string;
+  threadId?: string;
+};
+
+export type ImportGithubAppResponse = {
+  appId: string;
+  projectId: string;
+  threadId: string;
+};
+
+export type ListPublicAppsParams = {
+  limit?: number;
+  offset?: number;
+  q?: string;
+};
+
+export type ListAppsSummaryParams = ListPublicAppsParams & {
+  projectId?: string;
+};
+
+export type AppsSummary = {
+  mine: App[];
+  public: App[];
+  pagination: {
+    limit: number;
+    offset: number;
+    q: string | null;
+  };
+};
+
+export type ListLikedAppsParams = {
+  limit?: number;
+  offset?: number;
+};
+
+export type LikedAppListItem = {
+  likeId: string;
+  appId: string;
+  likedAt: string;
+  app: App;
+};
+
+export type LikedAppsList = {
+  items: LikedAppListItem[];
+  pageInfo: {
+    limit: number;
+    offset: number;
+    total: number;
+    hasMore: boolean;
+  };
+};
+
+export const APP_STATUS_LABEL: Record<AppStatus, string> = {
+  ready: 'Ready',
+  creating: 'Creating',
+  editing: 'Editing',
+  forking: 'Forking',
+  merging: 'Merging',
+  error: 'Error',
+  archived: 'Archived',
+};
+
+

package/src/data/attachment/remote.ts

@@ -0,0 +1,32 @@
+import { api } from '../../core/services/http';
+import { BaseRemote } from '../base-remote';
+import type { ServiceResponse } from '../types';
+import type {
+  PresignAttachmentsRequest,
+  PresignAttachmentsResponse,
+} from './types';
+
+export interface AttachmentRemoteDataSource {
+  presign(
+    payload: PresignAttachmentsRequest
+  ): Promise<ServiceResponse<PresignAttachmentsResponse>>;
+}
+
+class AttachmentRemoteDataSourceImpl
+  extends BaseRemote
+  implements AttachmentRemoteDataSource
+{
+  async presign(
+    payload: PresignAttachmentsRequest
+  ): Promise<ServiceResponse<PresignAttachmentsResponse>> {
+    const { data } = await api.post<ServiceResponse<PresignAttachmentsResponse>>(
+      '/v1/attachments/presign',
+      payload
+    );
+    return data;
+  }
+}
+
+export const attachmentRemoteDataSource: AttachmentRemoteDataSource =
+  new AttachmentRemoteDataSourceImpl();
+

package/src/data/attachment/repository.ts

@@ -0,0 +1,40 @@
+import type { AttachmentRemoteDataSource } from './remote';
+import { attachmentRemoteDataSource } from './remote';
+import type {
+  PresignAttachmentsRequest,
+  PresignAttachmentsResponse,
+  PresignedUpload,
+} from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface AttachmentRepository {
+  presign(payload: PresignAttachmentsRequest): Promise<PresignAttachmentsResponse>;
+  upload(upload: PresignedUpload, file: Blob | File): Promise<void>;
+}
+
+class AttachmentRepositoryImpl extends BaseRepository implements AttachmentRepository {
+  constructor(private readonly remote: AttachmentRemoteDataSource) {
+    super();
+  }
+
+  async presign(payload: PresignAttachmentsRequest): Promise<PresignAttachmentsResponse> {
+    const res = await this.remote.presign(payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async upload(upload: PresignedUpload, file: Blob | File): Promise<void> {
+    const resp = await fetch(upload.uploadUrl, {
+      method: 'PUT',
+      headers: upload.headers,
+      body: file,
+    });
+    if (!resp.ok) {
+      throw new Error(`upload failed: ${resp.status}`);
+    }
+  }
+}
+
+export const attachmentRepository: AttachmentRepository = new AttachmentRepositoryImpl(
+  attachmentRemoteDataSource
+);
+

package/src/data/attachment/types.ts

@@ -0,0 +1,42 @@
+export type AttachmentMeta = {
+  id: string;
+  name: string;
+  bucket: string;
+  path: string;
+  mimeType: string;
+  size: number;
+  checksum?: string;
+  width?: number;
+  height?: number;
+  durationMs?: number;
+  uploadStatus?: 'pending' | 'uploaded';
+  downloadUrl?: string;
+};
+
+export type PresignFile = {
+  name: string;
+  size: number;
+  mimeType: string;
+  checksum?: string;
+};
+
+export type PresignAttachmentsRequest = {
+  threadId: string;
+  files: PresignFile[];
+  appId?: string;
+};
+
+export type PresignedUpload = {
+  uploadUrl: string;
+  headers: Record<string, string>;
+  token: string | null;
+  attachment: AttachmentMeta;
+};
+
+export type PresignAttachmentsResponse = {
+  appId: string;
+  threadId: string;
+  expiresIn: number;
+  uploads: PresignedUpload[];
+};
+

package/src/data/base-remote.ts

@@ -0,0 +1,3 @@
+export abstract class BaseRemote {}
+
+

package/src/data/base-repository.ts

@@ -0,0 +1,11 @@
+import type { ServiceResponse } from './types';
+
+export abstract class BaseRepository {
+  protected unwrapOrThrow<T>(res: ServiceResponse<T>): T {
+    if (res.success && res.responseObject) return res.responseObject;
+    const msg = res.message || 'Request failed';
+    throw new Error(msg);
+  }
+}
+
+

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

@@ -0,0 +1,87 @@
+import { api } from '../../../core/services/http';
+import { BaseRemote } from '../../base-remote';
+import type { ServiceResponse } from '../../types';
+import type {
+  AppCommentLikeList,
+  AppCommentLikeMutationResult,
+  AppCommentLikeStatsResult,
+  CreateAppCommentLikeInput,
+  ListAppCommentLikesQuery,
+} from './types';
+
+export interface AppCommentLikesRemoteDataSource {
+  list(
+    appId: string,
+    commentId: string,
+    query?: ListAppCommentLikesQuery
+  ): Promise<ServiceResponse<AppCommentLikeList>>;
+  create(
+    appId: string,
+    commentId: string,
+    payload: CreateAppCommentLikeInput
+  ): Promise<ServiceResponse<AppCommentLikeMutationResult>>;
+  removeById(
+    appId: string,
+    commentId: string,
+    likeId: string
+  ): Promise<ServiceResponse<AppCommentLikeStatsResult>>;
+  removeMine(appId: string, commentId: string): Promise<ServiceResponse<AppCommentLikeStatsResult>>;
+}
+
+class AppCommentLikesRemoteDataSourceImpl
+  extends BaseRemote
+  implements AppCommentLikesRemoteDataSource
+{
+  async list(
+    appId: string,
+    commentId: string,
+    query?: ListAppCommentLikesQuery
+  ): Promise<ServiceResponse<AppCommentLikeList>> {
+    const params = query ? { ...query } : undefined;
+    const { data } = await api.get<ServiceResponse<AppCommentLikeList>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments/${encodeURIComponent(commentId)}/likes`,
+      { params }
+    );
+    return data;
+  }
+
+  async create(
+    appId: string,
+    commentId: string,
+    payload: CreateAppCommentLikeInput
+  ): Promise<ServiceResponse<AppCommentLikeMutationResult>> {
+    const { data } = await api.post<ServiceResponse<AppCommentLikeMutationResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments/${encodeURIComponent(commentId)}/likes`,
+      payload
+    );
+    return data;
+  }
+
+  async removeById(
+    appId: string,
+    commentId: string,
+    likeId: string
+  ): Promise<ServiceResponse<AppCommentLikeStatsResult>> {
+    const { data } = await api.delete<ServiceResponse<AppCommentLikeStatsResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments/${encodeURIComponent(commentId)}/likes/${encodeURIComponent(
+        likeId
+      )}`
+    );
+    return data;
+  }
+
+  async removeMine(
+    appId: string,
+    commentId: string
+  ): Promise<ServiceResponse<AppCommentLikeStatsResult>> {
+    const { data } = await api.delete<ServiceResponse<AppCommentLikeStatsResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/comments/${encodeURIComponent(commentId)}/likes/me`
+    );
+    return data;
+  }
+}
+
+export const appCommentLikesRemoteDataSource: AppCommentLikesRemoteDataSource =
+  new AppCommentLikesRemoteDataSourceImpl();
+
+

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

@@ -0,0 +1,61 @@
+import { BaseRepository } from '../../base-repository';
+import type { AppCommentLikesRemoteDataSource } from './remote';
+import { appCommentLikesRemoteDataSource } from './remote';
+import type {
+  AppCommentLikeList,
+  AppCommentLikeMutationResult,
+  AppCommentLikeStatsResult,
+  CreateAppCommentLikeInput,
+  ListAppCommentLikesQuery,
+} from './types';
+
+export interface AppCommentLikesRepository {
+  list(appId: string, commentId: string, query?: ListAppCommentLikesQuery): Promise<AppCommentLikeList>;
+  create(
+    appId: string,
+    commentId: string,
+    payload: CreateAppCommentLikeInput
+  ): Promise<AppCommentLikeMutationResult>;
+  removeById(appId: string, commentId: string, likeId: string): Promise<AppCommentLikeStatsResult>;
+  removeMine(appId: string, commentId: string): Promise<AppCommentLikeStatsResult>;
+}
+
+class AppCommentLikesRepositoryImpl extends BaseRepository implements AppCommentLikesRepository {
+  constructor(private readonly remote: AppCommentLikesRemoteDataSource) {
+    super();
+  }
+
+  async list(appId: string, commentId: string, query?: ListAppCommentLikesQuery): Promise<AppCommentLikeList> {
+    const res = await this.remote.list(appId, commentId, query);
+    return this.unwrapOrThrow(res);
+  }
+
+  async create(
+    appId: string,
+    commentId: string,
+    payload: CreateAppCommentLikeInput
+  ): Promise<AppCommentLikeMutationResult> {
+    const res = await this.remote.create(appId, commentId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async removeById(
+    appId: string,
+    commentId: string,
+    likeId: string
+  ): Promise<AppCommentLikeStatsResult> {
+    const res = await this.remote.removeById(appId, commentId, likeId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async removeMine(appId: string, commentId: string): Promise<AppCommentLikeStatsResult> {
+    const res = await this.remote.removeMine(appId, commentId);
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const appCommentLikesRepository: AppCommentLikesRepository = new AppCommentLikesRepositoryImpl(
+  appCommentLikesRemoteDataSource
+);
+
+