magicbell-js 0.0.3 → 0.1.0

package/src/project-client/services/integrations/models/unseen-hover.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unseenHover = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UnseenHover} unseenHover
+ * @property {string}
+ */
+export type UnseenHover = z.infer<typeof unseenHover>;
+
+/**
+ * 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 unseenHoverResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});
+
+/**
+ * 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 unseenHoverRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});

package/src/project-client/services/integrations/models/unseen-state.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unseenState = z.lazy(() => {
+  return z.object({
+    color: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UnseenState} unseenState
+ * @property {string}
+ */
+export type UnseenState = z.infer<typeof unseenState>;
+
+/**
+ * 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 unseenStateResponse = z.lazy(() => {
+  return z
+    .object({
+      color: z.string(),
+    })
+    .transform((data) => ({
+      color: data['color'],
+    }));
+});
+
+/**
+ * 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 unseenStateRequest = z.lazy(() => {
+  return z
+    .object({
+      color: z.string(),
+    })
+    .transform((data) => ({
+      color: data['color'],
+    }));
+});

package/src/project-client/services/integrations/models/unseen.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+
+import { UnseenHover, unseenHover, unseenHoverRequest, unseenHoverResponse } from './unseen-hover.js';
+import { UnseenState, unseenState, unseenStateRequest, unseenStateResponse } from './unseen-state.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unseen = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+    hover: unseenHover.optional(),
+    state: unseenState.optional(),
+    textColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Unseen} unseen
+ * @property {string}
+ * @property {UnseenHover}
+ * @property {UnseenState}
+ * @property {string}
+ */
+export type Unseen = z.infer<typeof unseen>;
+
+/**
+ * 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 unseenResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      hover: unseenHoverResponse.optional(),
+      state: unseenStateResponse.optional(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      hover: data['hover'],
+      state: data['state'],
+      textColor: data['textColor'],
+    }));
+});
+
+/**
+ * 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 unseenRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      hover: unseenHoverRequest.optional(),
+      state: unseenStateRequest.optional(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      hover: data['hover'],
+      state: data['state'],
+      textColor: data['textColor'],
+    }));
+});

package/src/project-client/services/integrations/models/webpush-config-collection.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+import { Links, links, linksRequest, linksResponse } from '../../common/links.js';
+import { WebpushConfig, webpushConfig, webpushConfigRequest, webpushConfigResponse } from './webpush-config.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const webpushConfigCollection = z.lazy(() => {
+  return z.object({
+    data: z.array(webpushConfig).optional(),
+    links: links.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {WebpushConfigCollection} webpushConfigCollection
+ * @property {WebpushConfig[]}
+ * @property {Links}
+ */
+export type WebpushConfigCollection = z.infer<typeof webpushConfigCollection>;
+
+/**
+ * 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 webpushConfigCollectionResponse = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(webpushConfigResponse).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 webpushConfigCollectionRequest = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(webpushConfigRequest).optional(),
+      links: linksRequest.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});

package/src/project-client/services/integrations/models/webpush-config-payload.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const webpushConfigPayload = z.lazy(() => {
+  return z.object({
+    privateKey: z.string().min(8).max(128),
+    publicKey: z.string().min(8).max(128),
+  });
+});
+
+/**
+ *
+ * @typedef  {WebpushConfigPayload} webpushConfigPayload
+ * @property {string} - VAPID private key - from the pair you generated.
+ * @property {string} - VAPID public key - generate one at https://tools.reactpwa.com/vapid.
+ */
+export type WebpushConfigPayload = z.infer<typeof webpushConfigPayload>;
+
+/**
+ * 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 webpushConfigPayloadResponse = z.lazy(() => {
+  return z
+    .object({
+      private_key: z.string().min(8).max(128),
+      public_key: z.string().min(8).max(128),
+    })
+    .transform((data) => ({
+      privateKey: data['private_key'],
+      publicKey: data['public_key'],
+    }));
+});
+
+/**
+ * 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 webpushConfigPayloadRequest = z.lazy(() => {
+  return z
+    .object({
+      privateKey: z.string().min(8).max(128),
+      publicKey: z.string().min(8).max(128),
+    })
+    .transform((data) => ({
+      private_key: data['privateKey'],
+      public_key: data['publicKey'],
+    }));
+});

package/src/project-client/services/integrations/models/webpush-config.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+
+import {
+  WebpushConfigPayload,
+  webpushConfigPayload,
+  webpushConfigPayloadRequest,
+  webpushConfigPayloadResponse,
+} from './webpush-config-payload.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const webpushConfig = z.lazy(() => {
+  return z.object({
+    config: webpushConfigPayload,
+    id: z.string(),
+    name: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {WebpushConfig} webpushConfig
+ * @property {WebpushConfigPayload}
+ * @property {string}
+ * @property {string}
+ */
+export type WebpushConfig = z.infer<typeof webpushConfig>;
+
+/**
+ * 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 webpushConfigResponse = z.lazy(() => {
+  return z
+    .object({
+      config: webpushConfigPayloadResponse,
+      id: z.string(),
+      name: z.string(),
+    })
+    .transform((data) => ({
+      config: data['config'],
+      id: data['id'],
+      name: data['name'],
+    }));
+});
+
+/**
+ * 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 webpushConfigRequest = z.lazy(() => {
+  return z
+    .object({
+      config: webpushConfigPayloadRequest,
+      id: z.string(),
+      name: z.string(),
+    })
+    .transform((data) => ({
+      config: data['config'],
+      id: data['id'],
+      name: data['name'],
+    }));
+});

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

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

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

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

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

@@ -0,0 +1,121 @@
+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 { AccessTokenCollection, accessTokenCollectionResponse } from './models/access-token-collection.js';
+import { CreateProjectTokenRequest, createProjectTokenRequestRequest } from './models/create-project-token-request.js';
+import { CreateTokenResponse, createTokenResponseResponse } from './models/create-token-response.js';
+import { DiscardTokenResponse, discardTokenResponseResponse } from './models/discard-token-response.js';
+import { FetchProjectTokensParams } from './request-params.js';
+
+export class JwtService extends BaseService {
+  /**
+   * Retrieves a list of all active project-level JWT tokens. Returns a paginated list showing token metadata including creation date, last used date, and expiration time. For security reasons, the actual token values are not included in the response.
+   * @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<AccessTokenCollection>>} OK
+   */
+  async fetchProjectTokens(
+    params?: FetchProjectTokensParams,
+    requestConfig?: RequestConfig,
+  ): Promise<HttpResponse<AccessTokenCollection>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/jwt/project')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: accessTokenCollectionResponse,
+        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<AccessTokenCollection>(request);
+  }
+
+  /**
+   * Creates a new project-level JWT token. These tokens provide project-wide access and should be carefully managed. Only administrators can create project tokens. The returned token should be securely stored as it cannot be retrieved again after creation.
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<CreateTokenResponse>>} Created
+   */
+  async createProjectJwt(
+    body: CreateProjectTokenRequest,
+    requestConfig?: RequestConfig,
+  ): Promise<HttpResponse<CreateTokenResponse>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('POST')
+      .setPath('/jwt/project')
+      .setRequestSchema(createProjectTokenRequestRequest)
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: createTokenResponseResponse,
+        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<CreateTokenResponse>(request);
+  }
+
+  /**
+   * Immediately revokes a project-level JWT token. Once revoked, any requests using this token will be rejected. This action is immediate and cannot be undone. Active sessions using this token will be terminated.
+   * @param {string} tokenId -
+   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<DiscardTokenResponse>>} OK
+   */
+  async discardProjectJwt(tokenId: string, requestConfig?: RequestConfig): Promise<HttpResponse<DiscardTokenResponse>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('DELETE')
+      .setPath('/jwt/project/{token_id}')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: discardTokenResponseResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam({
+        key: 'token_id',
+        value: tokenId,
+      })
+      .build();
+    return this.client.call<DiscardTokenResponse>(request);
+  }
+}

package/src/project-client/services/jwt/models/access-token-collection.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+import { Links, links, linksRequest, linksResponse } from '../../common/links.js';
+import { AccessToken, accessToken, accessTokenRequest, accessTokenResponse } from './access-token.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const accessTokenCollection = z.lazy(() => {
+  return z.object({
+    data: z.array(accessToken).optional(),
+    links: links.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {AccessTokenCollection} accessTokenCollection
+ * @property {AccessToken[]}
+ * @property {Links}
+ */
+export type AccessTokenCollection = z.infer<typeof accessTokenCollection>;
+
+/**
+ * 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 accessTokenCollectionResponse = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(accessTokenResponse).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 accessTokenCollectionRequest = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(accessTokenRequest).optional(),
+      links: linksRequest.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});

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

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const accessToken = z.lazy(() => {
+  return z.object({
+    createdAt: z.string(),
+    discardedAt: z.string().optional().nullable(),
+    expiresAt: z.string().optional(),
+    id: z.string().optional(),
+    name: z.string().optional().nullable(),
+  });
+});
+
+/**
+ *
+ * @typedef  {AccessToken} accessToken
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type AccessToken = z.infer<typeof accessToken>;
+
+/**
+ * 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 accessTokenResponse = z.lazy(() => {
+  return z
+    .object({
+      created_at: z.string(),
+      discarded_at: z.string().optional().nullable(),
+      expires_at: z.string().optional(),
+      id: z.string().optional(),
+      name: z.string().optional().nullable(),
+    })
+    .transform((data) => ({
+      createdAt: data['created_at'],
+      discardedAt: data['discarded_at'],
+      expiresAt: data['expires_at'],
+      id: data['id'],
+      name: data['name'],
+    }));
+});
+
+/**
+ * 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 accessTokenRequest = z.lazy(() => {
+  return z
+    .object({
+      createdAt: z.string(),
+      discardedAt: z.string().optional().nullable(),
+      expiresAt: z.string().optional(),
+      id: z.string().optional(),
+      name: z.string().optional().nullable(),
+    })
+    .transform((data) => ({
+      created_at: data['createdAt'],
+      discarded_at: data['discardedAt'],
+      expires_at: data['expiresAt'],
+      id: data['id'],
+      name: data['name'],
+    }));
+});

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const createProjectTokenRequest = z.lazy(() => {
+  return z.object({
+    expiry: z.number().gte(1).optional().nullable(),
+    name: z.string().max(255),
+  });
+});
+
+/**
+ *
+ * @typedef  {CreateProjectTokenRequest} createProjectTokenRequest
+ * @property {number} - The duration for which the token is valid (in seconds)
+ * @property {string} - The name of the token.
+ */
+export type CreateProjectTokenRequest = z.infer<typeof createProjectTokenRequest>;
+
+/**
+ * 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 createProjectTokenRequestResponse = z.lazy(() => {
+  return z
+    .object({
+      expiry: z.number().gte(1).optional().nullable(),
+      name: z.string().max(255),
+    })
+    .transform((data) => ({
+      expiry: data['expiry'],
+      name: data['name'],
+    }));
+});
+
+/**
+ * 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 createProjectTokenRequestRequest = z.lazy(() => {
+  return z
+    .object({
+      expiry: z.number().gte(1).optional().nullable(),
+      name: z.string().max(255),
+    })
+    .transform((data) => ({
+      expiry: data['expiry'],
+      name: data['name'],
+    }));
+});