magicbell-js 0.0.3 → 0.1.0

package/src/project-client/services/jwt/models/create-token-response.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const createTokenResponse = z.lazy(() => {
+  return z.object({
+    createdAt: z.string(),
+    expiresAt: z.string().optional().nullable(),
+    token: z.string(),
+    tokenId: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {CreateTokenResponse} createTokenResponse
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type CreateTokenResponse = z.infer<typeof createTokenResponse>;
+
+/**
+ * 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 createTokenResponseResponse = z.lazy(() => {
+  return z
+    .object({
+      created_at: z.string(),
+      expires_at: z.string().optional().nullable(),
+      token: z.string(),
+      token_id: z.string(),
+    })
+    .transform((data) => ({
+      createdAt: data['created_at'],
+      expiresAt: data['expires_at'],
+      token: data['token'],
+      tokenId: data['token_id'],
+    }));
+});
+
+/**
+ * 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 createTokenResponseRequest = z.lazy(() => {
+  return z
+    .object({
+      createdAt: z.string(),
+      expiresAt: z.string().optional().nullable(),
+      token: z.string(),
+      tokenId: z.string(),
+    })
+    .transform((data) => ({
+      created_at: data['createdAt'],
+      expires_at: data['expiresAt'],
+      token: data['token'],
+      token_id: data['tokenId'],
+    }));
+});

package/src/project-client/services/jwt/models/discard-token-response.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const discardTokenResponse = z.lazy(() => {
+  return z.object({
+    discardedAt: z.string(),
+    tokenId: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {DiscardTokenResponse} discardTokenResponse
+ * @property {string}
+ * @property {string}
+ */
+export type DiscardTokenResponse = z.infer<typeof discardTokenResponse>;
+
+/**
+ * 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 discardTokenResponseResponse = z.lazy(() => {
+  return z
+    .object({
+      discarded_at: z.string(),
+      token_id: z.string(),
+    })
+    .transform((data) => ({
+      discardedAt: data['discarded_at'],
+      tokenId: data['token_id'],
+    }));
+});
+
+/**
+ * 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 discardTokenResponseRequest = z.lazy(() => {
+  return z
+    .object({
+      discardedAt: z.string(),
+      tokenId: z.string(),
+    })
+    .transform((data) => ({
+      discarded_at: data['discardedAt'],
+      token_id: data['tokenId'],
+    }));
+});

package/src/project-client/services/jwt/models/index.ts

@@ -0,0 +1,5 @@
+export type { AccessToken } from './access-token.js';
+export type { AccessTokenCollection } from './access-token-collection.js';
+export type { CreateProjectTokenRequest } from './create-project-token-request.js';
+export type { CreateTokenResponse } from './create-token-response.js';
+export type { DiscardTokenResponse } from './discard-token-response.js';

package/src/project-client/services/jwt/request-params.ts

@@ -0,0 +1,5 @@
+export interface FetchProjectTokensParams {
+  limit?: number;
+  startingAfter?: string;
+  endingBefore?: string;
+}

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

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

package/src/project-client/services/notifications/models/delivery-plan-collection.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+import { Links, links, linksRequest, linksResponse } from '../../common/links.js';
+import { DeliveryPlan, deliveryPlan, deliveryPlanRequest, deliveryPlanResponse } from './delivery-plan.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const deliveryPlanCollection = z.lazy(() => {
+  return z.object({
+    data: z.array(deliveryPlan).optional(),
+    links: links.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {DeliveryPlanCollection} deliveryPlanCollection
+ * @property {DeliveryPlan[]}
+ * @property {Links}
+ */
+export type DeliveryPlanCollection = z.infer<typeof deliveryPlanCollection>;
+
+/**
+ * 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 deliveryPlanCollectionResponse = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(deliveryPlanResponse).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 deliveryPlanCollectionRequest = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(deliveryPlanRequest).optional(),
+      links: linksRequest.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});

package/src/project-client/services/notifications/models/delivery-plan.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const deliveryPlan = z.lazy(() => {
+  return z.object({
+    category: z.string().optional().nullable(),
+    completedAt: z.string().optional().nullable(),
+    id: z.string().optional(),
+    nextStep: z.number().optional(),
+    notificationId: z.string().optional(),
+    startedAt: z.string().optional().nullable(),
+    status: z.string().optional(),
+    topic: z.string().optional().nullable(),
+    userId: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {DeliveryPlan} deliveryPlan
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {number}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type DeliveryPlan = z.infer<typeof deliveryPlan>;
+
+/**
+ * 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 deliveryPlanResponse = z.lazy(() => {
+  return z
+    .object({
+      category: z.string().optional().nullable(),
+      completed_at: z.string().optional().nullable(),
+      id: z.string().optional(),
+      next_step: z.number().optional(),
+      notification_id: z.string().optional(),
+      started_at: z.string().optional().nullable(),
+      status: z.string().optional(),
+      topic: z.string().optional().nullable(),
+      user_id: z.string().optional(),
+    })
+    .transform((data) => ({
+      category: data['category'],
+      completedAt: data['completed_at'],
+      id: data['id'],
+      nextStep: data['next_step'],
+      notificationId: data['notification_id'],
+      startedAt: data['started_at'],
+      status: data['status'],
+      topic: data['topic'],
+      userId: data['user_id'],
+    }));
+});
+
+/**
+ * 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 deliveryPlanRequest = z.lazy(() => {
+  return z
+    .object({
+      category: z.string().optional().nullable(),
+      completedAt: z.string().optional().nullable(),
+      id: z.string().optional(),
+      nextStep: z.number().optional(),
+      notificationId: z.string().optional(),
+      startedAt: z.string().optional().nullable(),
+      status: z.string().optional(),
+      topic: z.string().optional().nullable(),
+      userId: z.string().optional(),
+    })
+    .transform((data) => ({
+      category: data['category'],
+      completed_at: data['completedAt'],
+      id: data['id'],
+      next_step: data['nextStep'],
+      notification_id: data['notificationId'],
+      started_at: data['startedAt'],
+      status: data['status'],
+      topic: data['topic'],
+      user_id: data['userId'],
+    }));
+});

package/src/project-client/services/notifications/models/index.ts

@@ -0,0 +1,2 @@
+export type { DeliveryPlan } from './delivery-plan.js';
+export type { DeliveryPlanCollection } from './delivery-plan-collection.js';

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

@@ -0,0 +1,45 @@
+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 { DeliveryPlanCollection, deliveryPlanCollectionResponse } from './models/delivery-plan-collection.js';
+
+export class NotificationsService extends BaseService {
+  /**
+   * Get the delivery plan for a notification.
+   * @param {string} notificationId -
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<DeliveryPlanCollection>>} OK
+   */
+  async getDeliveryplan(
+    notificationId: string,
+    requestConfig?: RequestConfig,
+  ): Promise<HttpResponse<DeliveryPlanCollection>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/notifications/{notification_id}/deliveryplan')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: deliveryPlanCollectionResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam({
+        key: 'notification_id',
+        value: notificationId,
+      })
+      .build();
+    return this.client.call<DeliveryPlanCollection>(request);
+  }
+}

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

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

package/src/project-client/services/users/models/index.ts

@@ -0,0 +1,2 @@
+export type { User } from './user.js';
+export type { UserCollection } from './user-collection.js';

package/src/project-client/services/users/models/user-collection.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+import { Links, links, linksRequest, linksResponse } from '../../common/links.js';
+import { User, user, userRequest, userResponse } from './user.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const userCollection = z.lazy(() => {
+  return z.object({
+    data: z.array(user).optional(),
+    links: links.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UserCollection} userCollection
+ * @property {User[]}
+ * @property {Links}
+ */
+export type UserCollection = z.infer<typeof userCollection>;
+
+/**
+ * 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 userCollectionResponse = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(userResponse).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 userCollectionRequest = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(userRequest).optional(),
+      links: linksRequest.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});

package/src/project-client/services/users/models/user.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const user = z.lazy(() => {
+  return z.object({
+    createdAt: z.string().optional().nullable(),
+    customAttributes: z.any().optional().nullable(),
+    email: z.string().optional().nullable(),
+    externalId: z.string().optional().nullable(),
+    firstName: z.string().optional().nullable(),
+    id: z.string().optional(),
+    lastName: z.string().optional().nullable(),
+    lastNotifiedAt: z.string().optional().nullable(),
+    lastSeenAt: z.string().optional().nullable(),
+    updatedAt: z.string().optional().nullable(),
+  });
+});
+
+/**
+ *
+ * @typedef  {User} user
+ * @property {string}
+ * @property {any}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type User = z.infer<typeof user>;
+
+/**
+ * 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 userResponse = z.lazy(() => {
+  return z
+    .object({
+      created_at: z.string().optional().nullable(),
+      custom_attributes: z.any().optional().nullable(),
+      email: z.string().optional().nullable(),
+      external_id: z.string().optional().nullable(),
+      first_name: z.string().optional().nullable(),
+      id: z.string().optional(),
+      last_name: z.string().optional().nullable(),
+      last_notified_at: z.string().optional().nullable(),
+      last_seen_at: z.string().optional().nullable(),
+      updated_at: z.string().optional().nullable(),
+    })
+    .transform((data) => ({
+      createdAt: data['created_at'],
+      customAttributes: data['custom_attributes'],
+      email: data['email'],
+      externalId: data['external_id'],
+      firstName: data['first_name'],
+      id: data['id'],
+      lastName: data['last_name'],
+      lastNotifiedAt: data['last_notified_at'],
+      lastSeenAt: data['last_seen_at'],
+      updatedAt: data['updated_at'],
+    }));
+});
+
+/**
+ * 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 userRequest = z.lazy(() => {
+  return z
+    .object({
+      createdAt: z.string().optional().nullable(),
+      customAttributes: z.any().optional().nullable(),
+      email: z.string().optional().nullable(),
+      externalId: z.string().optional().nullable(),
+      firstName: z.string().optional().nullable(),
+      id: z.string().optional(),
+      lastName: z.string().optional().nullable(),
+      lastNotifiedAt: z.string().optional().nullable(),
+      lastSeenAt: z.string().optional().nullable(),
+      updatedAt: z.string().optional().nullable(),
+    })
+    .transform((data) => ({
+      created_at: data['createdAt'],
+      custom_attributes: data['customAttributes'],
+      email: data['email'],
+      external_id: data['externalId'],
+      first_name: data['firstName'],
+      id: data['id'],
+      last_name: data['lastName'],
+      last_notified_at: data['lastNotifiedAt'],
+      last_seen_at: data['lastSeenAt'],
+      updated_at: data['updatedAt'],
+    }));
+});

package/src/project-client/services/users/request-params.ts

@@ -0,0 +1,6 @@
+export interface ListUsersParams {
+  limit?: number;
+  startingAfter?: string;
+  endingBefore?: string;
+  query?: string;
+}

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

@@ -0,0 +1,118 @@
+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 { User, userRequest, userResponse } from './models/user.js';
+import { UserCollection, userCollectionResponse } from './models/user-collection.js';
+import { ListUsersParams } from './request-params.js';
+
+export class UsersService extends BaseService {
+  /**
+   *
+   * @param {number} [params.limit] -
+   * @param {string} [params.startingAfter] -
+   * @param {string} [params.endingBefore] -
+   * @param {string} [params.query] -
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<UserCollection>>} OK
+   */
+  async listUsers(params?: ListUsersParams, requestConfig?: RequestConfig): Promise<HttpResponse<UserCollection>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/users')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: userCollectionResponse,
+        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,
+      })
+      .addQueryParam({
+        key: 'query',
+        value: params?.query,
+      })
+      .build();
+    return this.client.call<UserCollection>(request);
+  }
+
+  /**
+   * Creates a user with the provided details. The user will be associated with the project specified in the request context.
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<User>>} Created
+   */
+  async createUser(body: User, requestConfig?: RequestConfig): Promise<HttpResponse<User>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('POST')
+      .setPath('/users')
+      .setRequestSchema(userRequest)
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: userResponse,
+        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<User>(request);
+  }
+
+  /**
+   *
+   * @param {string} userId -
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<any>>} No Content
+   */
+  async deleteUser(userId: string, requestConfig?: RequestConfig): Promise<HttpResponse<void>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('DELETE')
+      .setPath('/users/{user_id}')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: z.undefined(),
+        contentType: ContentType.NoContent,
+        status: 204,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam({
+        key: 'user_id',
+        value: userId,
+      })
+      .build();
+    return this.client.call<void>(request);
+  }
+}

package/src/project-client.ts

@@ -0,0 +1 @@
+export * from './project-client/index.js';