@sublay/js 5.0.0

package/dist/index.js

@@ -0,0 +1,194 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SublayClient: () => SublayClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/client.ts
+var import_axios = __toESM(require("axios"));
+var SublayHttpClient = class {
+  instance;
+  constructor({ projectId }) {
+    this.instance = import_axios.default.create({
+      baseURL: `https://api.sublay.io/api/v5/${projectId}`
+    });
+  }
+};
+
+// src/modules/users/index.ts
+var users_exports = {};
+__export(users_exports, {
+  fetchUserByForeignId: () => fetchUserByForeignId,
+  fetchUserById: () => fetchUserById
+});
+
+// src/modules/users/fetchUserById.ts
+async function fetchUserById(client, data) {
+  const path = `/users/${data.userId}`;
+  const response = await client.instance.get(path);
+  return response.data;
+}
+
+// src/modules/users/fetchUserByForeignId.ts
+async function fetchUserByForeignId(client, data) {
+  const path = `/users/by-foreign-id`;
+  const params = {
+    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) : void 0,
+    secureMetadata: data.secureMetadata ? JSON.stringify(data.secureMetadata) : void 0
+  };
+  const response = await client.instance.get(path, {
+    params
+  });
+  return response.data;
+}
+
+// src/modules/entities/index.ts
+var entities_exports = {};
+__export(entities_exports, {
+  createEntity: () => createEntity,
+  deleteEntity: () => deleteEntity,
+  fetchEntity: () => fetchEntity,
+  fetchEntityByForeignId: () => fetchEntityByForeignId,
+  fetchEntityByShortId: () => fetchEntityByShortId,
+  fetchManyEntities: () => fetchManyEntities,
+  updateEntity: () => updateEntity
+});
+
+// src/modules/entities/createEntity.ts
+async function createEntity(client, data) {
+  const path = `/entities`;
+  const response = await client.instance.post(path, data);
+  return response.data;
+}
+
+// src/modules/entities/fetchEntity.ts
+async function fetchEntity(client, data) {
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.get(path);
+  return response.data;
+}
+
+// src/modules/entities/fetchEntityByForeignId.ts
+async function fetchEntityByForeignId(client, data) {
+  const path = `/entities/by-foreign-id`;
+  const response = await client.instance.get(path, { params: data });
+  return response.data;
+}
+
+// src/modules/entities/fetchEntityByShortId.ts
+async function fetchEntityByShortId(client, data) {
+  const path = `/entities/by-short-id`;
+  const response = await client.instance.get(path, { params: data });
+  return response.data;
+}
+
+// src/modules/entities/fetchManyEntities.ts
+async function fetchManyEntities(client, data) {
+  const path = `/entities`;
+  const response = await client.instance.get(path, {
+    params: data
+  });
+  return response.data;
+}
+
+// src/modules/entities/updateEntity.ts
+async function updateEntity(client, data) {
+  const { entityId, ...restOfProps } = data;
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.patch(path, restOfProps);
+  return response.data;
+}
+
+// src/modules/entities/deleteEntity.ts
+async function deleteEntity(client, data) {
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.delete(path);
+  return response.data;
+}
+
+// src/modules/comments/index.ts
+var comments_exports = {};
+__export(comments_exports, {
+  fetchComment: () => fetchComment,
+  fetchCommentByForeignId: () => fetchCommentByForeignId
+});
+
+// src/modules/comments/fetchComment.ts
+async function fetchComment(client, data) {
+  const path = `/comments/${data.commentId}`;
+  const response = await client.instance.get(path);
+  return response.data;
+}
+
+// src/modules/comments/fetchCommentByForeignId.ts
+async function fetchCommentByForeignId(client, data) {
+  const path = `/comments/by-foreign-id`;
+  const response = await client.instance.get(path, { params: data });
+  return response.data;
+}
+
+// src/index.ts
+var SublayClient = class _SublayClient {
+  http;
+  users;
+  entities;
+  comments;
+  constructor(http) {
+    this.http = http;
+    this.users = bindModule(users_exports, this.http);
+    this.entities = bindModule(entities_exports, this.http);
+    this.comments = bindModule(comments_exports, this.http);
+  }
+  static async init(config) {
+    const http = new SublayHttpClient(config);
+    return new _SublayClient(http);
+  }
+};
+function bindModule(module2, client) {
+  const bound = {};
+  for (const key in module2) {
+    bound[key] = (...args) => module2[key](client, ...args);
+  }
+  return bound;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SublayClient
+});

package/dist/index.mjs

@@ -0,0 +1,163 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/client.ts
+import axios from "axios";
+var SublayHttpClient = class {
+  instance;
+  constructor({ projectId }) {
+    this.instance = axios.create({
+      baseURL: `https://api.sublay.io/api/v5/${projectId}`
+    });
+  }
+};
+
+// src/modules/users/index.ts
+var users_exports = {};
+__export(users_exports, {
+  fetchUserByForeignId: () => fetchUserByForeignId,
+  fetchUserById: () => fetchUserById
+});
+
+// src/modules/users/fetchUserById.ts
+async function fetchUserById(client, data) {
+  const path = `/users/${data.userId}`;
+  const response = await client.instance.get(path);
+  return response.data;
+}
+
+// src/modules/users/fetchUserByForeignId.ts
+async function fetchUserByForeignId(client, data) {
+  const path = `/users/by-foreign-id`;
+  const params = {
+    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) : void 0,
+    secureMetadata: data.secureMetadata ? JSON.stringify(data.secureMetadata) : void 0
+  };
+  const response = await client.instance.get(path, {
+    params
+  });
+  return response.data;
+}
+
+// src/modules/entities/index.ts
+var entities_exports = {};
+__export(entities_exports, {
+  createEntity: () => createEntity,
+  deleteEntity: () => deleteEntity,
+  fetchEntity: () => fetchEntity,
+  fetchEntityByForeignId: () => fetchEntityByForeignId,
+  fetchEntityByShortId: () => fetchEntityByShortId,
+  fetchManyEntities: () => fetchManyEntities,
+  updateEntity: () => updateEntity
+});
+
+// src/modules/entities/createEntity.ts
+async function createEntity(client, data) {
+  const path = `/entities`;
+  const response = await client.instance.post(path, data);
+  return response.data;
+}
+
+// src/modules/entities/fetchEntity.ts
+async function fetchEntity(client, data) {
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.get(path);
+  return response.data;
+}
+
+// src/modules/entities/fetchEntityByForeignId.ts
+async function fetchEntityByForeignId(client, data) {
+  const path = `/entities/by-foreign-id`;
+  const response = await client.instance.get(path, { params: data });
+  return response.data;
+}
+
+// src/modules/entities/fetchEntityByShortId.ts
+async function fetchEntityByShortId(client, data) {
+  const path = `/entities/by-short-id`;
+  const response = await client.instance.get(path, { params: data });
+  return response.data;
+}
+
+// src/modules/entities/fetchManyEntities.ts
+async function fetchManyEntities(client, data) {
+  const path = `/entities`;
+  const response = await client.instance.get(path, {
+    params: data
+  });
+  return response.data;
+}
+
+// src/modules/entities/updateEntity.ts
+async function updateEntity(client, data) {
+  const { entityId, ...restOfProps } = data;
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.patch(path, restOfProps);
+  return response.data;
+}
+
+// src/modules/entities/deleteEntity.ts
+async function deleteEntity(client, data) {
+  const path = `/entities/${data.entityId}`;
+  const response = await client.instance.delete(path);
+  return response.data;
+}
+
+// src/modules/comments/index.ts
+var comments_exports = {};
+__export(comments_exports, {
+  fetchComment: () => fetchComment,
+  fetchCommentByForeignId: () => fetchCommentByForeignId
+});
+
+// src/modules/comments/fetchComment.ts
+async function fetchComment(client, data) {
+  const path = `/comments/${data.commentId}`;
+  const response = await client.instance.get(path);
+  return response.data;
+}
+
+// src/modules/comments/fetchCommentByForeignId.ts
+async function fetchCommentByForeignId(client, data) {
+  const path = `/comments/by-foreign-id`;
+  const response = await client.instance.get(path, { params: data });
+  return response.data;
+}
+
+// src/index.ts
+var SublayClient = class _SublayClient {
+  http;
+  users;
+  entities;
+  comments;
+  constructor(http) {
+    this.http = http;
+    this.users = bindModule(users_exports, this.http);
+    this.entities = bindModule(entities_exports, this.http);
+    this.comments = bindModule(comments_exports, this.http);
+  }
+  static async init(config) {
+    const http = new SublayHttpClient(config);
+    return new _SublayClient(http);
+  }
+};
+function bindModule(module, client) {
+  const bound = {};
+  for (const key in module) {
+    bound[key] = (...args) => module[key](client, ...args);
+  }
+  return bound;
+}
+export {
+  SublayClient
+};

package/dist/interfaces/IPaginatedResponse.d.ts

@@ -0,0 +1,11 @@
+export interface PaginationMetadata {
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalItems: number;
+    hasMore: boolean;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: PaginationMetadata;
+}

package/dist/modules/comments/fetchComment.d.ts

@@ -0,0 +1,5 @@
+import { SublayHttpClient } from "../../core/client";
+export interface FetchCommentProps {
+    commentId: string;
+}
+export declare function fetchComment(client: SublayHttpClient, data: FetchCommentProps): Promise<any>;

package/dist/modules/comments/fetchCommentByForeignId.d.ts

@@ -0,0 +1,5 @@
+import { SublayHttpClient } from "../../core/client";
+export interface FetchCommentByForeignIdProps {
+    foreignId: string;
+}
+export declare function fetchCommentByForeignId(client: SublayHttpClient, data: FetchCommentByForeignIdProps): Promise<any>;

package/dist/modules/comments/index.d.ts

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

package/dist/modules/entities/createEntity.d.ts

@@ -0,0 +1,17 @@
+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;
+}
+export declare function createEntity(client: SublayHttpClient, data: CreateEntityProps): Promise<any>;

package/dist/modules/entities/deleteEntity.d.ts

@@ -0,0 +1,5 @@
+import { SublayHttpClient } from "../../core/client";
+export interface DeleteEntityProps {
+    entityId: string;
+}
+export declare function deleteEntity(client: SublayHttpClient, data: DeleteEntityProps): Promise<any>;

package/dist/modules/entities/fetchEntity.d.ts

@@ -0,0 +1,5 @@
+import { SublayHttpClient } from "../../core/client";
+export interface FetchEntityProps {
+    entityId: string;
+}
+export declare function fetchEntity(client: SublayHttpClient, data: FetchEntityProps): Promise<any>;

package/dist/modules/entities/fetchEntityByForeignId.d.ts

@@ -0,0 +1,6 @@
+import { SublayHttpClient } from "../../core/client";
+export interface FetchEntityByForeignIdProps {
+    foreignId: string;
+    createIfNotFound?: boolean;
+}
+export declare function fetchEntityByForeignId(client: SublayHttpClient, data: FetchEntityByForeignIdProps): Promise<any>;

package/dist/modules/entities/fetchEntityByShortId.d.ts

@@ -0,0 +1,5 @@
+import { SublayHttpClient } from "../../core/client";
+export interface FetchEntityByShortIdProps {
+    shortId: string;
+}
+export declare function fetchEntityByShortId(client: SublayHttpClient, data: FetchEntityByShortIdProps): Promise<any>;

package/dist/modules/entities/fetchManyEntities.d.ts

@@ -0,0 +1,50 @@
+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;
+    sortBy?: "hot" | "top" | "controversial";
+    page?: number;
+    limit?: number;
+    timeFrame?: "hour" | "day" | "week" | "month" | "year";
+    userId?: string;
+    followedOnly?: "true";
+    keywordsFilters?: KeywordsFilters;
+    metadataFilters?: MetadataFilters;
+    titleFilters?: TextFilters;
+    contentFilters?: {
+        hasContent?: "true" | "false";
+        includes?: string | string[];
+        doesNotInclude?: string | string[];
+    };
+    attachmentsFilters?: AttachmentsFilters;
+    locationFilters?: LocationFilters;
+}
+export declare function fetchManyEntities(client: SublayHttpClient, data: FetchManyEntitiesProps): Promise<PaginatedResponse<any>>;

package/dist/modules/entities/index.d.ts

@@ -0,0 +1,8 @@
+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/dist/modules/entities/updateEntity.d.ts

@@ -0,0 +1,18 @@
+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];
+    };
+    metadata?: Record<string, any>;
+    mentions?: {
+        id: string;
+        username: string;
+    }[];
+}
+export declare function updateEntity(client: SublayHttpClient, data: UpdateEntityProps): Promise<any>;

package/dist/modules/users/fetchUserByForeignId.d.ts

@@ -0,0 +1,11 @@
+import { SublayHttpClient } from "../../core/client";
+export interface FetchUserByForeignIdProps {
+    foreignId: string;
+    name?: string;
+    username?: string;
+    avatar?: string;
+    bio?: string;
+    metadata?: Record<string, any>;
+    secureMetadata?: Record<string, any>;
+}
+export declare function fetchUserByForeignId(client: SublayHttpClient, data: FetchUserByForeignIdProps): Promise<any>;

package/dist/modules/users/fetchUserById.d.ts

@@ -0,0 +1,5 @@
+import { SublayHttpClient } from "../../core/client";
+export interface FetchUserByIdProps {
+    userId: string;
+}
+export declare function fetchUserById(client: SublayHttpClient, data: FetchUserByIdProps): Promise<any>;

package/dist/modules/users/index.d.ts

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

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sublay/js",
+  "version": "5.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "description": "Official JavaScript SDK for Sublay",
+  "author": "Sublay team",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "axios": "^1.8.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format cjs,esm",
+    "build:types": "tsc --emitDeclarationOnly",
+    "publish-beta": "pnpm publish --tag beta",
+    "publish-prod": "pnpm publish"
+  }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

package/src/core/client.ts

@@ -0,0 +1,15 @@
+import axios, { AxiosInstance } from "axios";
+
+export interface ClientConfig {
+  projectId: string;
+}
+
+export class SublayHttpClient {
+  instance: AxiosInstance;
+
+  constructor({ projectId }: ClientConfig) {
+    this.instance = axios.create({
+      baseURL: `https://api.sublay.io/api/v5/${projectId}`,
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+import { SublayHttpClient, ClientConfig } from "./core/client";
+import * as Users from "./modules/users";
+import * as Entities from "./modules/entities";
+import * as Comments from "./modules/comments";
+
+type BoundModule<
+  T extends Record<string, (client: SublayHttpClient, ...args: any[]) => any>
+> = {
+  [K in keyof T]: (
+    ...args: Parameters<T[K]> extends [any, ...infer R] ? R : never
+  ) => ReturnType<T[K]>;
+};
+
+export class SublayClient {
+  private http: SublayHttpClient;
+
+  public users: BoundModule<typeof Users>;
+  public entities: BoundModule<typeof Entities>;
+  public comments: BoundModule<typeof Comments>;
+
+  private constructor(http: SublayHttpClient) {
+    this.http = http;
+    this.users = bindModule(Users, this.http);
+    this.entities = bindModule(Entities, this.http);
+    this.comments = bindModule(Comments, this.http);
+  }
+
+  static async init(config: ClientConfig): Promise<SublayClient> {
+    const http = new SublayHttpClient(config);
+    return new SublayClient(http);
+  }
+}
+
+function bindModule<
+  T extends Record<string, (client: SublayHttpClient, ...args: any[]) => any>
+>(module: T, client: SublayHttpClient): BoundModule<T> {
+  const bound: any = {};
+  for (const key in module) {
+    bound[key] = (...args: any[]) => module[key](client, ...args);
+  }
+  return bound;
+}
+
+// Export pagination types
+export type { PaginatedResponse, PaginationMetadata } from "./interfaces/IPaginatedResponse";

package/src/interfaces/IPaginatedResponse.ts

@@ -0,0 +1,12 @@
+export interface PaginationMetadata {
+  page: number;
+  pageSize: number;
+  totalPages: number;
+  totalItems: number;
+  hasMore: boolean;
+}
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  pagination: PaginationMetadata;
+}

package/src/modules/comments/fetchComment.ts

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