@hexclave/shared 1.0.2 → 1.0.5

package/src/interface/crud/internal-api-keys.ts

@@ -0,0 +1,69 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import { yupBoolean, yupMixed, yupNumber, yupObject, yupString } from "../../schema-fields";
+
+const baseInternalApiKeysReadSchema = yupObject({
+  id: yupString().defined(),
+  description: yupString().defined(),
+  expires_at_millis: yupNumber().defined(),
+  manually_revoked_at_millis: yupNumber().optional(),
+  created_at_millis: yupNumber().defined(),
+});
+
+// Used for the result of the create endpoint
+export const internalApiKeysCreateInputSchema = yupObject({
+  description: yupString().defined(),
+  expires_at_millis: yupNumber().defined(),
+  has_publishable_client_key: yupBoolean().defined(),
+  has_secret_server_key: yupBoolean().defined(),
+  has_super_secret_admin_key: yupBoolean().defined(),
+});
+
+export const internalApiKeysCreateOutputSchema = baseInternalApiKeysReadSchema.concat(yupObject({
+  publishable_client_key: yupString().optional(),
+  secret_server_key: yupString().optional(),
+  super_secret_admin_key: yupString().optional(),
+}).defined());
+
+// Used for list, read and update endpoints after the initial creation
+export const internalApiKeysCrudAdminObfuscatedReadSchema = baseInternalApiKeysReadSchema.concat(yupObject({
+  publishable_client_key: yupObject({
+    last_four: yupString().defined(),
+  }).optional(),
+  secret_server_key: yupObject({
+    last_four: yupString().defined(),
+  }).optional(),
+  super_secret_admin_key: yupObject({
+    last_four: yupString().defined(),
+  }).optional(),
+}));
+
+export const internalApiKeysCrudAdminUpdateSchema = yupObject({
+  description: yupString().optional(),
+  revoked: yupBoolean().oneOf([true]).optional(),
+}).defined();
+
+export const internalApiKeysCrudAdminDeleteSchema = yupMixed();
+
+export const internalApiKeysCrud = createCrud({
+  adminReadSchema: internalApiKeysCrudAdminObfuscatedReadSchema,
+  adminUpdateSchema: internalApiKeysCrudAdminUpdateSchema,
+  adminDeleteSchema: internalApiKeysCrudAdminDeleteSchema,
+  docs: {
+    adminList: {
+      hidden: true,
+    },
+    adminRead: {
+      hidden: true,
+    },
+    adminCreate: {
+      hidden: true,
+    },
+    adminUpdate: {
+      hidden: true,
+    },
+    adminDelete: {
+      hidden: true,
+    },
+  },
+});
+export type InternalApiKeysCrud = CrudTypeOf<typeof internalApiKeysCrud>;

package/src/interface/crud/invoices.ts

@@ -0,0 +1,36 @@
+import type * as yup from "yup";
+import { yupArray, yupBoolean, yupNumber, yupObject, yupString } from "../../schema-fields";
+
+const invoiceStatusSchema = yupString().oneOf([
+  "draft",
+  "open",
+  "paid",
+  "uncollectible",
+  "void",
+]).nullable().defined();
+
+export const customerInvoiceReadSchema = yupObject({
+  created_at_millis: yupNumber().defined(),
+  status: invoiceStatusSchema,
+  amount_total: yupNumber().integer().defined(),
+  hosted_invoice_url: yupString().nullable().defined(),
+}).defined();
+
+export type CustomerInvoiceRead = yup.InferType<typeof customerInvoiceReadSchema>;
+
+export const customerInvoicesListResponseSchema = yupObject({
+  items: yupArray(customerInvoiceReadSchema).defined(),
+  is_paginated: yupBoolean().oneOf([true]).defined(),
+  pagination: yupObject({
+    next_cursor: yupString().nullable().defined(),
+  }).defined(),
+}).defined();
+
+export type CustomerInvoicesListResponse = yup.InferType<typeof customerInvoicesListResponseSchema>;
+
+export type ListCustomerInvoicesOptions = {
+  customer_type: "user" | "team",
+  customer_id: string,
+  cursor?: string,
+  limit?: number,
+};

package/src/interface/crud/items.ts

@@ -0,0 +1,24 @@
+import { createCrud, CrudTypeOf } from "../../crud";
+import { yupBoolean, yupNumber, yupObject, yupString } from "../../schema-fields";
+
+
+const itemReadSchema = yupObject({
+  id: yupString().defined(),
+  display_name: yupString().defined(),
+  quantity: yupNumber().defined(),
+}).defined();
+
+const itemUpdateSchema = yupObject({
+  delta: yupNumber().defined(),
+  expires_at: yupString().optional(),
+  description: yupString().optional(),
+  allow_negative: yupBoolean().optional(),
+}).defined();
+
+
+export const itemCrud = createCrud({
+  clientReadSchema: itemReadSchema,
+  serverUpdateSchema: itemUpdateSchema,
+});
+
+export type ItemCrud = CrudTypeOf<typeof itemCrud>;

package/src/interface/crud/notification-preferences.ts

@@ -0,0 +1,33 @@
+import { createCrud, CrudTypeOf } from "../../crud";
+import { yupBoolean, yupObject, yupString } from "../../schema-fields";
+
+
+const notificationPreferenceReadSchema = yupObject({
+  notification_category_id: yupString().defined(),
+  notification_category_name: yupString().defined(),
+  enabled: yupBoolean().defined(),
+  can_disable: yupBoolean().defined(),
+}).defined();
+
+const notificationPreferenceUpdateSchema = yupObject({
+  enabled: yupBoolean().defined(),
+}).defined();
+
+export const notificationPreferenceCrud = createCrud({
+  clientReadSchema: notificationPreferenceReadSchema,
+  clientUpdateSchema: notificationPreferenceUpdateSchema,
+  docs: {
+    clientList: {
+      summary: "List notification preferences",
+      description: "Get all notification preferences for a user, showing which notification categories are enabled or disabled.",
+      tags: ["Emails"],
+    },
+    clientUpdate: {
+      summary: "Update notification preference",
+      description: "Enable or disable a specific notification category for a user.",
+      tags: ["Emails"],
+    },
+  },
+});
+
+export type NotificationPreferenceCrud = CrudTypeOf<typeof notificationPreferenceCrud>;

package/src/interface/crud/oauth-providers.ts

@@ -0,0 +1,91 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import {
+  oauthProviderAccountIdSchema,
+  oauthProviderAllowConnectedAccountsSchema,
+  oauthProviderAllowSignInSchema,
+  oauthProviderEmailSchema,
+  oauthProviderIdSchema,
+  oauthProviderProviderConfigIdSchema,
+  oauthProviderTypeSchema,
+  userIdOrMeSchema,
+  yupMixed,
+  yupObject,
+  yupString
+} from "../../schema-fields";
+
+export const oauthProviderClientReadSchema = yupObject({
+  user_id: userIdOrMeSchema.defined(),
+  id: oauthProviderIdSchema.defined(),
+  email: oauthProviderEmailSchema.optional(),
+  provider_config_id: oauthProviderProviderConfigIdSchema.defined(),
+  type: oauthProviderTypeSchema.defined(),
+  allow_sign_in: oauthProviderAllowSignInSchema.defined(),
+  allow_connected_accounts: oauthProviderAllowConnectedAccountsSchema.defined(),
+}).defined();
+
+export const oauthProviderServerReadSchema = oauthProviderClientReadSchema.concat(yupObject({
+  account_id: oauthProviderAccountIdSchema.defined(),
+}));
+
+export const oauthProviderCrudClientUpdateSchema = yupObject({
+  allow_sign_in: oauthProviderAllowSignInSchema.optional(),
+  allow_connected_accounts: oauthProviderAllowConnectedAccountsSchema.optional(),
+}).defined();
+
+export const oauthProviderCrudServerUpdateSchema = oauthProviderCrudClientUpdateSchema.concat(yupObject({
+  email: oauthProviderEmailSchema.optional(),
+  account_id: oauthProviderAccountIdSchema.optional(),
+}));
+
+export const oauthProviderCrudServerCreateSchema = yupObject({
+  user_id: userIdOrMeSchema.defined(),
+  provider_config_id: yupString().defined(),
+  email: oauthProviderEmailSchema.optional(),
+  allow_sign_in: oauthProviderAllowSignInSchema.defined(),
+  allow_connected_accounts: oauthProviderAllowConnectedAccountsSchema.defined(),
+  account_id: oauthProviderAccountIdSchema.defined(),
+}).defined();
+
+export const oauthProviderCrudClientDeleteSchema = yupMixed();
+
+export const oauthProviderCrud = createCrud({
+  clientReadSchema: oauthProviderClientReadSchema,
+  clientUpdateSchema: oauthProviderCrudClientUpdateSchema,
+  clientDeleteSchema: oauthProviderCrudClientDeleteSchema,
+  serverReadSchema: oauthProviderServerReadSchema,
+  serverUpdateSchema: oauthProviderCrudServerUpdateSchema,
+  serverCreateSchema: oauthProviderCrudServerCreateSchema,
+  docs: {
+    clientRead: {
+      summary: "Get an OAuth provider",
+      description: "Retrieves a specific OAuth provider by the user ID and the OAuth provider ID.",
+      tags: ["Oauth"],
+    },
+    serverCreate: {
+      summary: "Create an OAuth provider",
+      description: "Add a new OAuth provider for a user.",
+      tags: ["Oauth"],
+    },
+    serverUpdate: {
+      summary: "Update an OAuth provider",
+      description: "Updates an existing OAuth provider. Only the values provided will be updated.",
+      tags: ["Oauth"],
+    },
+    clientUpdate: {
+      summary: "Update an OAuth provider",
+      description: "Updates an existing OAuth provider for a user.",
+      tags: ["Oauth"],
+    },
+    clientDelete: {
+      summary: "Delete an OAuth provider",
+      description: "Removes an OAuth provider for a given user.",
+      tags: ["Oauth"],
+    },
+    clientList: {
+      summary: "List OAuth providers",
+      description: "Retrieves a list of all OAuth providers for a user.",
+      tags: ["Oauth"],
+    },
+  }
+});
+export type OAuthProviderCrud = CrudTypeOf<typeof oauthProviderCrud>;

package/src/interface/crud/products.ts

@@ -0,0 +1,42 @@
+import type * as yup from "yup";
+import { inlineProductSchema, yupArray, yupBoolean, yupNumber, yupObject, yupString } from "../../schema-fields";
+
+const customerProductSwitchOptionSchema = yupObject({
+  product_id: yupString().defined(),
+  product: inlineProductSchema.defined(),
+}).defined();
+
+export const customerProductReadSchema = yupObject({
+  id: yupString().nullable().defined(),
+  quantity: yupNumber().defined(),
+  product: inlineProductSchema.defined(),
+  /** @deprecated Product ownership is independent of purchase type. Will be removed in a future version. */
+  type: yupString().oneOf(["one_time", "subscription"]).optional(),
+  /** @deprecated Subscription management will move to a dedicated endpoint. Will be removed in a future version. */
+  subscription: yupObject({
+    subscription_id: yupString().nullable().defined(),
+    current_period_end: yupString().nullable().defined(),
+    cancel_at_period_end: yupBoolean().defined(),
+    is_cancelable: yupBoolean().defined(),
+  }).nullable().optional(),
+  switch_options: yupArray(customerProductSwitchOptionSchema).optional(),
+}).defined();
+
+export type CustomerProductRead = yup.InferType<typeof customerProductReadSchema>;
+
+export const customerProductsListResponseSchema = yupObject({
+  items: yupArray(customerProductReadSchema).defined(),
+  is_paginated: yupBoolean().oneOf([true]).defined(),
+  pagination: yupObject({
+    next_cursor: yupString().nullable().defined(),
+  }).defined(),
+}).defined();
+
+export type CustomerProductsListResponse = yup.InferType<typeof customerProductsListResponseSchema>;
+
+export type ListCustomerProductsOptions = {
+  customer_type: "user" | "team" | "custom",
+  customer_id: string,
+  cursor?: string,
+  limit?: number,
+};

package/src/interface/crud/project-api-keys.ts

@@ -0,0 +1,100 @@
+import * as yup from "yup";
+import { CrudTypeOf, createCrud } from "../../crud";
+import { userIdOrMeSchema, yupBoolean, yupNumber, yupObject, yupString } from "../../schema-fields";
+import { typedFromEntries } from "../../utils/objects";
+
+function createApiKeyCrud<T extends string, IdFieldName extends string, IdSchema extends yup.Schema<any>>(type: T, idFieldName: IdFieldName, idSchema: IdSchema) {
+  const projectApiKeysReadSchema = yupObject({
+    id: yupString().defined(),
+    description: yupString().defined(),
+    expires_at_millis: yupNumber().optional(),
+    manually_revoked_at_millis: yupNumber().optional(),
+    created_at_millis: yupNumber().defined(),
+    is_public: yupBoolean().defined(),
+    value: yupObject({
+      last_four: yupString().defined(),
+    }).defined(),
+    type: yupString().oneOf([type]).defined(),
+    ...typedFromEntries([[idFieldName, idSchema]]),
+  });
+
+  const projectApiKeysUpdateSchema = yupObject({
+    description: yupString().optional(),
+    revoked: yupBoolean().oneOf([true]).optional(),
+  }).defined();
+
+  const projectApiKeysCrud = createCrud({
+    clientReadSchema: projectApiKeysReadSchema,
+    clientUpdateSchema: projectApiKeysUpdateSchema,
+    docs: {
+      clientCreate: {
+        description: `Create a new ${type} API key`,
+        displayName: `Create ${type} API key`,
+        tags: ["API Keys"],
+        summary: `Create ${type} API key`,
+      },
+      clientList: {
+        description: `List all ${type} API keys for the project with their metadata and status`,
+        displayName: `List ${type} API keys`,
+        summary: `List ${type} API keys`,
+        tags: ["API Keys"],
+      },
+      clientRead: {
+        description: `Get details of a specific ${type} API key`,
+        displayName: `Get ${type} API key`,
+        summary: `Get ${type} API key details`,
+        tags: ["API Keys"],
+      },
+      clientUpdate: {
+        description: `Update an ${type} API key`,
+        displayName: `Update ${type} API key`,
+        summary: `Update ${type} API key`,
+        tags: ["API Keys"],
+      },
+      serverDelete: {
+        description: `Delete an ${type} API key`,
+        displayName: `Delete ${type} API key`,
+        summary: `Delete ${type} API key`,
+        tags: ["API Keys"],
+      },
+    },
+  });
+
+  // Used for the result of the create endpoint
+  const projectApiKeysCreateInputSchema = yupObject({
+    description: yupString().defined(),
+    expires_at_millis: yupNumber().nullable().defined(),
+    is_public: yupBoolean().optional(),
+    /*
+    prefix: yupString().optional().nonEmpty().test("prefix", "Prefix must contain only alphanumeric characters and underscores", (value) => {
+      if (!value) return true;
+      return /^[a-zA-Z0-9_]+$/.test(value);
+    }),
+    */
+    ...typedFromEntries([[idFieldName, idSchema]]),
+  });
+  const projectApiKeysCreateOutputSchema = projectApiKeysReadSchema.omit(["value"]).concat(yupObject({
+    value: yupString().defined(),
+  }));
+
+  return {
+    crud: projectApiKeysCrud,
+    createInputSchema: projectApiKeysCreateInputSchema,
+    createOutputSchema: projectApiKeysCreateOutputSchema,
+  };
+}
+
+
+export const {
+  crud: userApiKeysCrud,
+  createInputSchema: userApiKeysCreateInputSchema,
+  createOutputSchema: userApiKeysCreateOutputSchema,
+} = createApiKeyCrud("user", "user_id", userIdOrMeSchema.defined());
+export type UserApiKeysCrud = CrudTypeOf<typeof userApiKeysCrud>;
+
+export const {
+  crud: teamApiKeysCrud,
+  createInputSchema: teamApiKeysCreateInputSchema,
+  createOutputSchema: teamApiKeysCreateOutputSchema,
+} = createApiKeyCrud("team", "team_id", yupString().defined());
+export type TeamApiKeysCrud = CrudTypeOf<typeof teamApiKeysCrud>;

package/src/interface/crud/project-permissions.ts

@@ -0,0 +1,118 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import * as schemaFields from "../../schema-fields";
+import { yupMixed, yupObject } from "../../schema-fields";
+import { WebhookEvent } from "../webhooks";
+
+// =============== Project permissions =================
+
+export const projectPermissionsCrudClientReadSchema = yupObject({
+  id: schemaFields.permissionDefinitionIdSchema.defined(),
+  user_id: schemaFields.userIdSchema.defined(),
+}).defined();
+
+export const projectPermissionsCrudServerCreateSchema = yupObject({
+}).defined();
+
+export const projectPermissionsCrudServerDeleteSchema = yupMixed();
+
+export const projectPermissionsCrud = createCrud({
+  clientReadSchema: projectPermissionsCrudClientReadSchema,
+  serverCreateSchema: projectPermissionsCrudServerCreateSchema,
+  serverDeleteSchema: projectPermissionsCrudServerDeleteSchema,
+  docs: {
+    clientList: {
+      summary: "List project permissions",
+      description: "List global permissions of the current user. `user_id=me` must be set for client requests. `(user_id, permission_id)` together uniquely identify a permission.",
+      tags: ["Permissions"],
+    },
+    serverList: {
+      summary: "List project permissions",
+      description: "Query and filter the permission with `user_id` and `permission_id`. `(user_id, permission_id)` together uniquely identify a permission.",
+      tags: ["Permissions"],
+    },
+    serverCreate: {
+      summary: "Grant a global permission to a user",
+      description: "Grant a global permission to a user (the permission must be created first on the Hexclave dashboard)",
+      tags: ["Permissions"],
+    },
+    serverDelete: {
+      summary: "Revoke a global permission from a user",
+      description: "Revoke a global permission from a user",
+      tags: ["Permissions"],
+    },
+  },
+});
+export type ProjectPermissionsCrud = CrudTypeOf<typeof projectPermissionsCrud>;
+
+export const projectPermissionCreatedWebhookEvent = {
+  type: "project_permission.created",
+  schema: projectPermissionsCrud.server.readSchema,
+  metadata: {
+    summary: "Project Permission Created",
+    description: "This event is triggered when a project permission is created.",
+    tags: ["Users"],
+  },
+} satisfies WebhookEvent<typeof projectPermissionsCrud.server.readSchema>;
+
+export const projectPermissionDeletedWebhookEvent = {
+  type: "project_permission.deleted",
+  schema: projectPermissionsCrud.server.readSchema,
+  metadata: {
+    summary: "Project Permission Deleted",
+    description: "This event is triggered when a project permission is deleted.",
+    tags: ["Users"],
+  },
+} satisfies WebhookEvent<typeof projectPermissionsCrud.server.readSchema>;
+
+// =============== Project permission definitions =================
+
+export const projectPermissionDefinitionsCrudAdminReadSchema = yupObject({
+  id: schemaFields.permissionDefinitionIdSchema.defined(),
+  description: schemaFields.teamPermissionDescriptionSchema.optional(),
+  contained_permission_ids: schemaFields.containedPermissionIdsSchema.defined(),
+}).defined();
+
+export const projectPermissionDefinitionsCrudAdminCreateSchema = yupObject({
+  id: schemaFields.customPermissionDefinitionIdSchema.defined(),
+  description: schemaFields.teamPermissionDescriptionSchema.optional(),
+  contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional(),
+}).defined();
+
+export const projectPermissionDefinitionsCrudAdminUpdateSchema = yupObject({
+  id: schemaFields.customPermissionDefinitionIdSchema.optional(),
+  description: schemaFields.teamPermissionDescriptionSchema.optional(),
+  contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional(),
+}).defined();
+
+export const projectPermissionDefinitionsCrudAdminDeleteSchema = yupMixed();
+
+export const projectPermissionDefinitionsCrud = createCrud({
+  adminReadSchema: projectPermissionDefinitionsCrudAdminReadSchema,
+  adminCreateSchema: projectPermissionDefinitionsCrudAdminCreateSchema,
+  adminUpdateSchema: projectPermissionDefinitionsCrudAdminUpdateSchema,
+  adminDeleteSchema: projectPermissionDefinitionsCrudAdminDeleteSchema,
+  docs: {
+    adminList: {
+      summary: "List project permission definitions",
+      description: "Query and filter project permission definitions (the equivalent of listing permissions on the Hexclave dashboard)",
+      tags: ["Permissions"],
+    },
+    adminCreate: {
+      summary: "Create a new project permission definition",
+      description: "Create a new project permission definition (the equivalent of creating a new permission on the Hexclave dashboard)",
+      tags: ["Permissions"],
+    },
+    adminUpdate: {
+      summary: "Update a project permission definition",
+      description: "Update a project permission definition (the equivalent of updating a permission on the Hexclave dashboard)",
+      tags: ["Permissions"],
+    },
+    adminDelete: {
+      summary: "Delete a project permission definition",
+      description: "Delete a project permission definition (the equivalent of deleting a permission on the Hexclave dashboard)",
+      tags: ["Permissions"],
+    },
+  },
+});
+
+export type ProjectPermissionDefinitionsCrud = CrudTypeOf<typeof projectPermissionDefinitionsCrud>;