@sublay/js 5.0.0

package/src/modules/comments/fetchCommentByForeignId.ts

@@ -0,0 +1,14 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface FetchCommentByForeignIdProps {
+  foreignId: string;
+}
+
+export async function fetchCommentByForeignId(
+  client: SublayHttpClient,
+  data: FetchCommentByForeignIdProps
+): Promise<any> {
+  const path = `/comments/by-foreign-id`;
+  const response = await client.instance.get<any>(path, { params: data });
+  return response.data;
+}

package/src/modules/comments/index.ts

@@ -0,0 +1,4 @@
+import { fetchComment } from "./fetchComment";
+import { fetchCommentByForeignId } from "./fetchCommentByForeignId";
+
+export { fetchComment, fetchCommentByForeignId };

package/src/modules/entities/createEntity.ts

@@ -0,0 +1,27 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface CreateEntityProps {
+  foreignId?: string;
+  sourceId?: string;
+  spaceId?: string;
+  title?: string;
+  content?: string;
+  attachments?: Record<string, any>[];
+  keywords?: string[];
+  location?: {
+    latitude: number;
+    longitude: number;
+  };
+  metadata?: Record<string, any>;
+  userId?: string;
+}
+
+// TODO: Replace "any" with Entity once we have types here too
+export async function createEntity(
+  client: SublayHttpClient,
+  data: CreateEntityProps
+): Promise<any> {
+  const path = `/entities`; // assuming client handles prefix like /{projectId}
+  const response = await client.instance.post<any>(path, data);
+  return response.data;
+}

package/src/modules/entities/deleteEntity.ts

@@ -0,0 +1,14 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface DeleteEntityProps {
+  entityId: string;
+}
+
+export async function deleteEntity(
+  client: SublayHttpClient,
+  data: DeleteEntityProps
+): Promise<any> {
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.delete<any>(path);
+  return response.data;
+}

package/src/modules/entities/fetchEntity.ts

@@ -0,0 +1,14 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface FetchEntityProps {
+  entityId: string;
+}
+
+export async function fetchEntity(
+  client: SublayHttpClient,
+  data: FetchEntityProps
+): Promise<any> {
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.get<any>(path);
+  return response.data;
+}

package/src/modules/entities/fetchEntityByForeignId.ts

@@ -0,0 +1,15 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface FetchEntityByForeignIdProps {
+  foreignId: string;
+  createIfNotFound?: boolean;
+}
+
+export async function fetchEntityByForeignId(
+  client: SublayHttpClient,
+  data: FetchEntityByForeignIdProps
+): Promise<any> {
+  const path = `/entities/by-foreign-id`;
+  const response = await client.instance.get<any>(path, { params: data });
+  return response.data;
+}

package/src/modules/entities/fetchEntityByShortId.ts

@@ -0,0 +1,14 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface FetchEntityByShortIdProps {
+  shortId: string;
+}
+
+export async function fetchEntityByShortId(
+  client: SublayHttpClient,
+  data: FetchEntityByShortIdProps
+): Promise<any> {
+  const path = `/entities/by-short-id`;
+  const response = await client.instance.get<any>(path, { params: data });
+  return response.data;
+}

package/src/modules/entities/fetchManyEntities.ts

@@ -0,0 +1,79 @@
+import { SublayHttpClient } from "../../core/client";
+import { PaginatedResponse } from "../../interfaces/IPaginatedResponse";
+
+export interface KeywordsFilters {
+  includes?: string[];
+  doesNotInclude?: string[];
+}
+
+export interface MetadataFilters {
+  includes?: { [key: string]: any };
+  doesNotInclude?: { [key: string]: any };
+  exists?: string[];
+  doesNotExist?: string[];
+}
+
+export interface TextFilters {
+  hasTitle?: "true" | "false";
+  includes?: string | string[];
+  doesNotInclude?: string | string[];
+}
+
+export interface AttachmentsFilters {
+  hasAttachments?: "true" | "false";
+}
+
+export interface LocationFilters {
+  latitude: string;
+  longitude: string;
+  radius: string;
+}
+
+export interface FetchManyEntitiesProps {
+  sourceId?: string;
+  spaceId?: string;
+
+  // Sorting & Pagination
+  sortBy?: "hot" | "top" | "controversial";
+  page?: number;
+  limit?: number;
+
+  // Time-based filtering
+  timeFrame?: "hour" | "day" | "week" | "month" | "year";
+
+  userId?: string;
+  followedOnly?: "true";
+
+  // Keyword filters
+  keywordsFilters?: KeywordsFilters;
+
+  // Metadata filters
+  metadataFilters?: MetadataFilters;
+
+  // Title filtering
+  titleFilters?: TextFilters;
+
+  // Content filtering
+  contentFilters?: {
+    hasContent?: "true" | "false";
+    includes?: string | string[];
+    doesNotInclude?: string | string[];
+  };
+
+  // Media filtering
+  attachmentsFilters?: AttachmentsFilters;
+
+  // Location filtering
+  locationFilters?: LocationFilters;
+}
+
+export async function fetchManyEntities(
+  client: SublayHttpClient,
+  data: FetchManyEntitiesProps
+): Promise<PaginatedResponse<any>> {
+  const path = `/entities`;
+  const response = await client.instance.get<PaginatedResponse<any>>(path, {
+    params: data,
+  });
+  return response.data;
+}

package/src/modules/entities/index.ts

@@ -0,0 +1,17 @@
+import { createEntity } from "./createEntity";
+import { fetchEntity } from "./fetchEntity";
+import { fetchEntityByForeignId } from "./fetchEntityByForeignId";
+import { fetchEntityByShortId } from "./fetchEntityByShortId";
+import { fetchManyEntities } from "./fetchManyEntities";
+import { updateEntity } from "./updateEntity";
+import { deleteEntity } from "./deleteEntity";
+
+export {
+  createEntity,
+  fetchEntity,
+  fetchEntityByForeignId,
+  fetchEntityByShortId,
+  fetchManyEntities,
+  updateEntity,
+  deleteEntity,
+};

package/src/modules/entities/updateEntity.ts

@@ -0,0 +1,28 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface UpdateEntityProps {
+  entityId: string;
+  title?: string;
+  content?: string;
+  attachments?: Record<string, any>[];
+  keywords?: string[];
+  location?: {
+    type: "Point";
+    coordinates: [number, number]; // [longitude, latitude]
+  };
+  metadata?: Record<string, any>;
+  mentions?: {
+    id: string;
+    username: string;
+  }[];
+}
+
+export async function updateEntity(
+  client: SublayHttpClient,
+  data: UpdateEntityProps
+): Promise<any> {
+  const { entityId, ...restOfProps } = data;
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.patch<any>(path, restOfProps);
+  return response.data;
+}

package/src/modules/users/fetchUserByForeignId.ts

@@ -0,0 +1,40 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface FetchUserByForeignIdProps {
+  foreignId: string;
+  name?: string;
+  username?: string;
+  avatar?: string;
+  bio?: string;
+  // birthdate?: string; // ISO format string
+  // location?: string;  // "lat,lng" string format (e.g. "32.0853,34.7818")
+  metadata?: Record<string, any>;
+  secureMetadata?: Record<string, any>;
+}
+
+export async function fetchUserByForeignId(
+  client: SublayHttpClient,
+  data: FetchUserByForeignIdProps
+): Promise<any> {
+  const path = `/users/by-foreign-id`;
+
+  const params: Record<string, any> = {
+    foreignId: data.foreignId,
+    name: data.name,
+    username: data.username,
+    avatar: data.avatar,
+    bio: data.bio,
+    // birthdate: data.birthdate,
+    // location: data.location,
+    metadata: data.metadata ? JSON.stringify(data.metadata) : undefined,
+    secureMetadata: data.secureMetadata
+      ? JSON.stringify(data.secureMetadata)
+      : undefined,
+  };
+
+  const response = await client.instance.get<any>(path, {
+    params,
+  });
+
+  return response.data;
+}

package/src/modules/users/fetchUserById.ts

@@ -0,0 +1,15 @@
+import { SublayHttpClient } from "../../core/client";
+
+export interface FetchUserByIdProps {
+  userId: string;
+}
+
+// TODO: Replace "any" with Entity once we have types here too
+export async function fetchUserById(
+  client: SublayHttpClient,
+  data: FetchUserByIdProps
+): Promise<any> {
+  const path = `/users/${data.userId}`; // assuming client handles prefix like /{projectId}
+  const response = await client.instance.get<any>(path);
+  return response.data;
+}

package/src/modules/users/index.ts

@@ -0,0 +1,4 @@
+import { fetchUserById } from "./fetchUserById";
+import { fetchUserByForeignId } from "./fetchUserByForeignId";
+
+export { fetchUserById, fetchUserByForeignId };

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}