magicbell-js 0.0.3 → 0.1.0

package/src/project-client/http/transport/types.ts

@@ -0,0 +1,51 @@
+import { ZodType } from 'zod';
+
+import { ThrowableError } from '../errors/throwable-error.js';
+import { SerializationStyle } from '../serialization/base-serializer.js';
+import { ContentType, HttpMethod, RetryOptions, SdkConfig, ValidationOptions } from '../types.js';
+
+export interface ResponseDefinition {
+  schema: ZodType;
+  contentType: ContentType;
+  status: number;
+}
+
+export interface ErrorDefinition {
+  error: new (...args: any[]) => ThrowableError;
+  contentType: ContentType;
+  status: number;
+}
+
+export interface CreateRequestParameters<Page = unknown[]> {
+  baseUrl: string;
+  method: HttpMethod;
+  body?: any;
+  headers: Map<string, RequestParameter>;
+  queryParams: Map<string, RequestParameter>;
+  pathParams: Map<string, RequestParameter>;
+  path: string;
+  config: SdkConfig;
+  responses: ResponseDefinition[];
+  errors: ErrorDefinition[];
+  requestSchema: ZodType;
+  requestContentType: ContentType;
+  validation: ValidationOptions;
+  retry: RetryOptions;
+  pagination?: RequestPagination<Page>;
+}
+
+export interface RequestParameter {
+  key: string | undefined;
+  value: unknown;
+  explode: boolean;
+  encode: boolean;
+  style: SerializationStyle;
+  isLimit: boolean;
+  isOffset: boolean;
+}
+
+export interface RequestPagination<Page> {
+  pageSize: number;
+  pagePath: string[];
+  pageSchema?: ZodType<Page, any, any>;
+}

package/src/project-client/http/types.ts

@@ -0,0 +1,74 @@
+import { ZodType } from 'zod';
+
+import { Environment } from './environment.js';
+import { Request } from './transport/request.js';
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+
+export interface SdkConfig {
+  baseUrl?: string;
+  environment?: Environment;
+  timeoutMs?: number;
+  token?: string;
+  retry?: RetryOptions;
+  validation?: ValidationOptions;
+}
+
+export interface HttpMetadata {
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+}
+
+export interface HttpResponse<T = unknown> {
+  data?: T;
+  metadata: HttpMetadata;
+  raw: ArrayBuffer;
+}
+
+export interface RequestHandler {
+  next?: RequestHandler;
+
+  handle<T>(request: Request): Promise<HttpResponse<T>>;
+  stream<T>(request: Request): AsyncGenerator<HttpResponse<T>>;
+}
+
+export enum ContentType {
+  Json = 'json',
+  Xml = 'xml',
+  Pdf = 'pdf',
+  Image = 'image',
+  File = 'file',
+  Binary = 'binary',
+  FormUrlEncoded = 'form',
+  Text = 'text',
+  MultipartFormData = 'multipartFormData',
+  EventStream = 'eventStream',
+  NoContent = 'noContent',
+}
+
+export interface Options<T> {
+  responseSchema: ZodType<T, any, any>;
+  requestSchema?: ZodType;
+  body?: any;
+  requestContentType?: ContentType;
+  responseContentType?: ContentType;
+  abortSignal?: AbortSignal;
+  queryParams?: Record<string, unknown>;
+  retry?: RetryOptions;
+}
+
+export interface RequestConfig {
+  retry?: RetryOptions;
+  validation?: ValidationOptions;
+  baseUrl?: string;
+}
+
+export interface RetryOptions {
+  attempts: number;
+  delayMs?: number;
+}
+
+export interface ValidationOptions {
+  responseValidation?: boolean;
+}

package/src/project-client/http/utils/content-type.ts

@@ -0,0 +1,33 @@
+import { ContentType } from '../types.js';
+
+export function getContentTypeDefinition(contentType: string): ContentType {
+  if (contentType.startsWith('application/') && contentType.includes('xml')) {
+    return ContentType.Xml;
+  }
+
+  if (contentType.toLowerCase() === 'application/x-www-form-urlencoded') {
+    return ContentType.FormUrlEncoded;
+  }
+
+  if (contentType.toLowerCase() === 'text/event-stream') {
+    return ContentType.EventStream;
+  }
+
+  if (contentType.toLowerCase().startsWith('text/')) {
+    return ContentType.Text;
+  }
+
+  if (contentType.toLowerCase().startsWith('image/')) {
+    return ContentType.Image;
+  }
+
+  if (contentType.toLowerCase() === 'application/octet-stream') {
+    return ContentType.Binary;
+  }
+
+  if (contentType.toLowerCase() === 'application/json') {
+    return ContentType.Json;
+  }
+
+  return ContentType.Json;
+}

package/src/project-client/http/utils/line-decoder.ts

@@ -0,0 +1,35 @@
+export class LineDecoder {
+  private lineBuffer = '';
+  private decoder = new TextDecoder();
+  private encoder = new TextEncoder();
+
+  /**
+   * Splits the given chunk into lines.
+   * Stores incomplete lines in a buffer and returns them when the next chunk arrives.
+   */
+  public splitLines(chunk: Uint8Array): Uint8Array[] {
+    this.lineBuffer += this.decoder.decode(chunk);
+
+    let lineEndIndex;
+    const lines: Uint8Array[] = [];
+    while ((lineEndIndex = this.lineBuffer.indexOf('\n')) >= 0) {
+      const line = this.lineBuffer.slice(0, lineEndIndex + 1); // Include the newline character
+      this.lineBuffer = this.lineBuffer.slice(lineEndIndex + 1);
+      if (line.length > 1) {
+        lines.push(this.encoder.encode(line));
+      }
+    }
+
+    return lines;
+  }
+
+  /** Returns the remaining lines in the buffer. */
+  public flush(): Uint8Array[] {
+    if (this.lineBuffer.length === 0) {
+      return [];
+    }
+    const lines = [this.encoder.encode(this.lineBuffer)];
+    this.lineBuffer = '';
+    return lines;
+  }
+}

package/src/project-client/http/utils/response-matcher.ts

@@ -0,0 +1,25 @@
+import { ResponseDefinition } from '../transport/types.js';
+import { ContentType, HttpResponse } from '../types.js';
+import { getContentTypeDefinition } from './content-type.js';
+
+export class ResponseMatcher {
+  constructor(private responses: ResponseDefinition[]) {}
+
+  public getResponseDefinition(response: HttpResponse): ResponseDefinition | undefined {
+    const rawContentType = response.metadata.headers['content-type']?.toLocaleLowerCase() || '';
+    const contentType = getContentTypeDefinition(rawContentType);
+    const statusCode = response.metadata.status;
+
+    if (!this.responses.length) {
+      return;
+    }
+
+    if (this.responses.length === 1) {
+      return this.responses[0];
+    }
+
+    return this.responses.find((response) => {
+      return response.contentType === contentType && response.status === statusCode;
+    });
+  }
+}

package/src/project-client/index.ts

@@ -0,0 +1,94 @@
+import { Environment } from './http/environment.js';
+import { SdkConfig } from './http/types.js';
+import { BroadcastsService } from './services/broadcasts/index.js';
+import { ChannelsService } from './services/channels/index.js';
+import { EventsService } from './services/events/index.js';
+import { IntegrationsService } from './services/integrations/index.js';
+import { JwtService } from './services/jwt/index.js';
+import { NotificationsService } from './services/notifications/index.js';
+import { UsersService } from './services/users/index.js';
+
+export { Environment } from './http/environment.js';
+export * from './http/index.js';
+export * from './services/broadcasts/index.js';
+export * from './services/channels/index.js';
+export * from './services/common/index.js';
+export * from './services/events/index.js';
+export * from './services/integrations/index.js';
+export * from './services/jwt/index.js';
+export * from './services/notifications/index.js';
+export * from './services/users/index.js';
+
+export class Client {
+  public readonly broadcasts: BroadcastsService;
+
+  public readonly channels: ChannelsService;
+
+  public readonly events: EventsService;
+
+  public readonly integrations: IntegrationsService;
+
+  public readonly jwt: JwtService;
+
+  public readonly notifications: NotificationsService;
+
+  public readonly users: UsersService;
+
+  constructor(public config: SdkConfig) {
+    this.broadcasts = new BroadcastsService(this.config);
+
+    this.channels = new ChannelsService(this.config);
+
+    this.events = new EventsService(this.config);
+
+    this.integrations = new IntegrationsService(this.config);
+
+    this.jwt = new JwtService(this.config);
+
+    this.notifications = new NotificationsService(this.config);
+
+    this.users = new UsersService(this.config);
+  }
+
+  set baseUrl(baseUrl: string) {
+    this.broadcasts.baseUrl = baseUrl;
+    this.channels.baseUrl = baseUrl;
+    this.events.baseUrl = baseUrl;
+    this.integrations.baseUrl = baseUrl;
+    this.jwt.baseUrl = baseUrl;
+    this.notifications.baseUrl = baseUrl;
+    this.users.baseUrl = baseUrl;
+  }
+
+  set environment(environment: Environment) {
+    this.broadcasts.baseUrl = environment;
+    this.channels.baseUrl = environment;
+    this.events.baseUrl = environment;
+    this.integrations.baseUrl = environment;
+    this.jwt.baseUrl = environment;
+    this.notifications.baseUrl = environment;
+    this.users.baseUrl = environment;
+  }
+
+  set timeoutMs(timeoutMs: number) {
+    this.broadcasts.timeoutMs = timeoutMs;
+    this.channels.timeoutMs = timeoutMs;
+    this.events.timeoutMs = timeoutMs;
+    this.integrations.timeoutMs = timeoutMs;
+    this.jwt.timeoutMs = timeoutMs;
+    this.notifications.timeoutMs = timeoutMs;
+    this.users.timeoutMs = timeoutMs;
+  }
+
+  set token(token: string) {
+    this.broadcasts.token = token;
+    this.channels.token = token;
+    this.events.token = token;
+    this.integrations.token = token;
+    this.jwt.token = token;
+    this.notifications.token = token;
+    this.users.token = token;
+  }
+}
+
+// c029837e0e474b76bc487506e8799df5e3335891efe4fb02bda7a1441840310c

package/src/project-client/services/base-service.ts

@@ -0,0 +1,27 @@
+import { HttpClient } from '../http/client.js';
+import { Environment } from '../http/environment.js';
+import { SdkConfig } from '../http/types.js';
+
+export class BaseService {
+  public client: HttpClient;
+
+  constructor(public config: SdkConfig) {
+    this.client = new HttpClient(this.config);
+  }
+
+  set baseUrl(baseUrl: string) {
+    this.config.baseUrl = baseUrl;
+  }
+
+  set environment(environment: Environment) {
+    this.config.environment = environment;
+  }
+
+  set timeoutMs(timeoutMs: number) {
+    this.config.timeoutMs = timeoutMs;
+  }
+
+  set token(token: string) {
+    this.config.token = token;
+  }
+}

package/src/project-client/services/broadcasts/broadcasts-service.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+
+import { Environment } from '../../http/environment.js';
+import { ThrowableError } from '../../http/errors/throwable-error.js';
+import { SerializationStyle } from '../../http/serialization/base-serializer.js';
+import { RequestBuilder } from '../../http/transport/request-builder.js';
+import { ContentType, HttpResponse, RequestConfig } from '../../http/types.js';
+import { BaseService } from '../base-service.js';
+import { Broadcast, broadcastRequest, broadcastResponse } from './models/broadcast.js';
+import { BroadcastCollection, broadcastCollectionResponse } from './models/broadcast-collection.js';
+import { ListBroadcastsParams } from './request-params.js';
+
+export class BroadcastsService extends BaseService {
+  /**
+   * Retrieves a paginated list of broadcasts for the project. Returns basic information about each broadcast including its creation time and status.
+   * @param {number} [params.limit] -
+   * @param {string} [params.startingAfter] -
+   * @param {string} [params.endingBefore] -
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<BroadcastCollection>>} OK
+   */
+  async listBroadcasts(
+    params?: ListBroadcastsParams,
+    requestConfig?: RequestConfig,
+  ): Promise<HttpResponse<BroadcastCollection>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/broadcasts')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: broadcastCollectionResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addQueryParam({
+        key: 'limit',
+        value: params?.limit,
+      })
+      .addQueryParam({
+        key: 'starting_after',
+        value: params?.startingAfter,
+      })
+      .addQueryParam({
+        key: 'ending_before',
+        value: params?.endingBefore,
+      })
+      .build();
+    return this.client.call<BroadcastCollection>(request);
+  }
+
+  /**
+   * Creates a new broadcast message. When a broadcast is created, it generates individual notifications for relevant users within the project.
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<Broadcast>>} Created
+   */
+  async createBroadcast(body: Broadcast, requestConfig?: RequestConfig): Promise<HttpResponse<Broadcast>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('POST')
+      .setPath('/broadcasts')
+      .setRequestSchema(broadcastRequest)
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: broadcastResponse,
+        contentType: ContentType.Json,
+        status: 201,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addHeaderParam({ key: 'Content-Type', value: 'application/json' })
+      .addBody(body)
+      .build();
+    return this.client.call<Broadcast>(request);
+  }
+
+  /**
+   * Retrieves detailed information about a specific broadcast by its ID. Includes the broadcast's configuration and current status.
+   * @param {string} broadcastId -
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<Broadcast>>} OK
+   */
+  async fetchBroadcast(broadcastId: string, requestConfig?: RequestConfig): Promise<HttpResponse<Broadcast>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/broadcasts/{broadcast_id}')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: broadcastResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam({
+        key: 'broadcast_id',
+        value: broadcastId,
+      })
+      .build();
+    return this.client.call<Broadcast>(request);
+  }
+}

package/src/project-client/services/broadcasts/index.ts

@@ -0,0 +1,2 @@
+export { BroadcastsService } from './broadcasts-service.js';
+export * from './models/index.js';

package/src/project-client/services/broadcasts/models/broadcast-collection.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+import { Links, links, linksRequest, linksResponse } from '../../common/links.js';
+import { Broadcast, broadcast, broadcastRequest, broadcastResponse } from './broadcast.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const broadcastCollection = z.lazy(() => {
+  return z.object({
+    data: z.array(broadcast).optional(),
+    links: links.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {BroadcastCollection} broadcastCollection
+ * @property {Broadcast[]}
+ * @property {Links}
+ */
+export type BroadcastCollection = z.infer<typeof broadcastCollection>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const broadcastCollectionResponse = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(broadcastResponse).optional(),
+      links: linksResponse.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const broadcastCollectionRequest = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(broadcastRequest).optional(),
+      links: linksRequest.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});

package/src/project-client/services/broadcasts/models/broadcast-status.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+
+import { Errors, errors, errorsRequest, errorsResponse } from './errors.js';
+import { Summary, summary, summaryRequest, summaryResponse } from './summary.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const broadcastStatus = z.lazy(() => {
+  return z.object({
+    errors: z.array(errors).nullable(),
+    status: z.string(),
+    summary: summary,
+  });
+});
+
+/**
+ *
+ * @typedef  {BroadcastStatus} broadcastStatus
+ * @property {Errors[]}
+ * @property {StatusStatus}
+ * @property {Summary}
+ */
+export type BroadcastStatus = z.infer<typeof broadcastStatus>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const broadcastStatusResponse = z.lazy(() => {
+  return z
+    .object({
+      errors: z.array(errorsResponse).nullable(),
+      status: z.string(),
+      summary: summaryResponse,
+    })
+    .transform((data) => ({
+      errors: data['errors'],
+      status: data['status'],
+      summary: data['summary'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const broadcastStatusRequest = z.lazy(() => {
+  return z
+    .object({
+      errors: z.array(errorsRequest).nullable(),
+      status: z.string(),
+      summary: summaryRequest,
+    })
+    .transform((data) => ({
+      errors: data['errors'],
+      status: data['status'],
+      summary: data['summary'],
+    }));
+});