@nangohq/types 0.39.23 → 0.39.25

package/dist/api.d.ts

@@ -1,19 +1,31 @@
-export interface ApiError<TCode extends string> {
+export interface ApiError<TCode extends string, TErrors = undefined> {
     error: {
         code: TCode;
         message?: string | undefined;
+        errors?: TErrors;
     };
 }
+export interface ValidationError {
+    code: string;
+    message: string;
+    path: (string | number)[];
+}
+export type ResDefaultErrors = ApiError<'not_found'> | ApiError<'invalid_query_params', ValidationError[]> | ApiError<'invalid_body', ValidationError[]> | ApiError<'feature_disabled'>;
+export type EndpointMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
 /**
  * API Request/Response type
  */
 export interface Endpoint<T extends {
+    Method: EndpointMethod;
+    Path: string;
     Params?: Record<string, any>;
     Body?: Record<string, any>;
     Querystring?: Record<string, any>;
     Error?: ApiError<any> | never;
     Success: Record<string, any> | never;
 }> {
+    Method: T['Method'];
+    Path: T['Path'];
     /**
      * URL params
      */
@@ -37,9 +49,9 @@ export interface Endpoint<T extends {
     /**
      * Response body for any error
      */
-    Errors: T['Error'];
+    Errors: ResDefaultErrors | T['Error'];
     /**
      * Response body (success + error)
      */
-    Reply: T['Error'] extends ApiError<any> ? T['Error'] | T['Success'] : T['Success'];
+    Reply: ResDefaultErrors | (T['Error'] extends ApiError<any> ? T['Error'] | T['Success'] : T['Success']);
 }

package/dist/api.endpoints.d.ts

@@ -0,0 +1,18 @@
+import type { EndpointMethod } from './api';
+import type { SearchLogs } from './logs/api';
+import type { GetOnboardingStatus } from './onboarding/api';
+export type APIEndpoints = SearchLogs | GetOnboardingStatus;
+/**
+ * Automatically narrow endpoints type with Method + Path
+ */
+export type APIEndpointsPicker<TMethod extends EndpointMethod, TPath extends APIEndpoints['Path']> = Extract<APIEndpoints, {
+    Method: TMethod;
+    Path: TPath;
+}>;
+/**
+ * Automatically narrow endpoints type with Path
+ * Useful to get allowed methods
+ */
+export type APIEndpointsPickerWithPath<TPath extends APIEndpoints['Path']> = Extract<APIEndpoints, {
+    Path: TPath;
+}>;

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 export type * from './db.js';
+export type * from './api.js';
+export type * from './api.endpoints.js';
 export type * from './onboarding/db.js';
 export type * from './onboarding/api.js';
 export type * from './record/api.js';
+export type * from './logs/api.js';
+export type * from './logs/messages.js';

package/dist/logs/api.d.ts

@@ -0,0 +1,19 @@
+import type { ApiError, Endpoint } from '../api';
+import type { OperationRow } from './messages';
+export type SearchLogs = Endpoint<{
+    Method: 'POST';
+    Path: '/api/v1/logs/search';
+    Querystring: {
+        env: string;
+    };
+    Body: {
+        limit?: number;
+    };
+    Error: ApiError<'invalid_query_params'>;
+    Success: {
+        data: OperationRow[];
+        pagination: {
+            total: number;
+        };
+    };
+}>;

package/dist/logs/messages.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Level of the log and operation
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Free form JSON (not indexed)
+ */
+export type MessageMeta = Record<any, any>;
+/**
+ * Kind of messages
+ * - log: classic string message
+ * - http: an HTTP request with request/response added to the log
+ */
+export type MessageType = 'log' | 'http';
+/**
+ * Error code attached to the message
+ * Not used yet
+ */
+export type MessageCode = 'success';
+/**
+ * State of the Operation
+ */
+export type MessageState = 'waiting' | 'running' | 'success' | 'failed' | 'timeout' | 'cancelled';
+/**
+ * Operations
+ */
+export interface MessageOpSync {
+    type: 'sync';
+    action: 'pause' | 'unpause' | 'run' | 'run_full' | 'cancel' | 'init';
+}
+export interface MessageOpProxy {
+    type: 'proxy';
+}
+export interface MessageOpAction {
+    type: 'action';
+}
+export interface MessageOpAuth {
+    type: 'auth';
+}
+export interface MessageOpToken {
+    type: 'token';
+}
+export interface MessageOpAdmin {
+    type: 'admin';
+    action: 'impersonation';
+}
+export interface MessageOpWebhook {
+    type: 'webhook';
+    action: 'incoming' | 'outgoing';
+}
+export interface MessageOpDeploy {
+    type: 'deploy';
+    action: 'prebuilt' | 'custom';
+}
+export type MessageOperation = MessageOpSync | MessageOpProxy | MessageOpAction | MessageOpWebhook | MessageOpDeploy | MessageOpAuth | MessageOpAdmin | MessageOpToken;
+/**
+ * Full schema
+ */
+export type MessageRow = {
+    id: string;
+    source: 'internal' | 'user';
+    level: LogLevel;
+    type: MessageType;
+    message: string;
+    title: string | null;
+    state: MessageState;
+    code: MessageCode | null;
+    accountId: number | null;
+    accountName: string | null;
+    environmentId: number | null;
+    environmentName: string | null;
+    configId: number | null;
+    configName: string | null;
+    connectionId: number | null;
+    connectionName: string | null;
+    syncId: string | null;
+    syncName: string | null;
+    jobId: string | null;
+    userId: number | null;
+    parentId: string | null;
+    error: {
+        name: string;
+        message: string;
+    } | null;
+    request: {
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+    } | null;
+    response: {
+        code: number;
+        headers: Record<string, string>;
+    } | null;
+    meta: MessageMeta | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string | null;
+    endedAt: string | null;
+} & {
+    operation: MessageOperation | null;
+};
+/**
+ * What is required to insert a Message
+ */
+export type OperationRequired = 'operation' | 'message';
+export type OperationRowInsert = Pick<MessageRow, OperationRequired> & Partial<Omit<MessageRow, OperationRequired>>;
+export type OperationRow = Pick<MessageRow, OperationRequired> & Omit<MessageRow, OperationRequired>;
+/**
+ * What is required to insert a Message
+ */
+export type MessageRowInsert = Pick<MessageRow, 'type' | 'message'> & Partial<Omit<MessageRow, 'type' | 'message'>> & {
+    id?: string | undefined;
+};

package/dist/onboarding/api.d.ts

@@ -1,8 +1,10 @@
 import type { ApiError, Endpoint } from '../api';
 import type { NangoRecord } from '../record/api';
 export type GetOnboardingStatus = Endpoint<{
-    Params: {
-        foo: 'bar';
+    Method: 'GET';
+    Path: '/api/v1/onboarding';
+    Querystring: {
+        env: string;
     };
     Error: ApiError<'onboarding_dev_only'> | ApiError<'no_onboarding'> | ApiError<'failed_to_get_records'> | ApiError<'invalid_query_params'>;
     Success: {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nangohq/types",
-    "version": "0.39.23",
+    "version": "0.39.25",
     "description": "Types used in Nango applications",
     "type": "module",
     "typings": "dist/index.d.ts",