@base44/sdk 0.8.17 → 0.8.19

package/dist/modules/auth.js

@@ -20,7 +20,6 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
         },
         // Redirects the user to the app's login page
         redirectToLogin(nextUrl) {
-            var _a;
             // This function only works in a browser environment
             if (typeof window === "undefined") {
                 throw new Error("Login method can only be used in a browser environment");
@@ -30,34 +29,42 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
                 ? new URL(nextUrl, window.location.origin).toString()
                 : window.location.href;
             // Build the login URL
-            const loginUrl = `${(_a = options.appBaseUrl) !== null && _a !== void 0 ? _a : ""}/login?from_url=${encodeURIComponent(redirectUrl)}`;
+            const loginUrl = `${options.appBaseUrl}/login?from_url=${encodeURIComponent(redirectUrl)}`;
             // Redirect to the login page
             window.location.href = loginUrl;
         },
+        // Redirects the user to a provider's login page
+        loginWithProvider(provider, fromUrl = "/") {
+            // Build the full redirect URL
+            const redirectUrl = new URL(fromUrl, window.location.origin).toString();
+            // Build the provider login URL (google is the default, so no provider path needed)
+            const providerPath = provider === "google" ? "" : `/${provider}`;
+            const loginUrl = `${options.appBaseUrl}/api/apps/auth${providerPath}/login?app_id=${appId}&from_url=${encodeURIComponent(redirectUrl)}`;
+            // Redirect to the provider login page
+            window.location.href = loginUrl;
+        },
         // Logout the current user
-        // Removes the token from localStorage and optionally redirects to a URL or reloads the page
         logout(redirectUrl) {
-            // Remove token from axios headers
+            // Remove token from axios headers (always do this)
             delete axios.defaults.headers.common["Authorization"];
-            // Remove token from localStorage
-            if (typeof window !== "undefined" && window.localStorage) {
-                try {
-                    window.localStorage.removeItem("base44_access_token");
-                    // Remove "token" that is set by the built-in SDK of platform version 2
-                    window.localStorage.removeItem("token");
-                }
-                catch (e) {
-                    console.error("Failed to remove token from localStorage:", e);
-                }
-            }
-            // Redirect if a URL is provided
+            // Only do the rest if in a browser environment
             if (typeof window !== "undefined") {
-                if (redirectUrl) {
-                    window.location.href = redirectUrl;
-                }
-                else {
-                    window.location.reload();
+                // Remove token from localStorage
+                if (window.localStorage) {
+                    try {
+                        window.localStorage.removeItem("base44_access_token");
+                        // Remove "token" that is set by the built-in SDK of platform version 2
+                        window.localStorage.removeItem("token");
+                    }
+                    catch (e) {
+                        console.error("Failed to remove token from localStorage:", e);
+                    }
                 }
+                // Determine the from_url parameter
+                const fromUrl = redirectUrl || window.location.href;
+                // Redirect to server-side logout endpoint to clear HTTP-only cookies
+                const logoutUrl = `${options.appBaseUrl}/api/apps/auth/logout?from_url=${encodeURIComponent(fromUrl)}`;
+                window.location.href = logoutUrl;
             }
         },
         // Set authentication token

package/dist/modules/auth.types.d.ts

@@ -90,8 +90,8 @@ export interface ResetPasswordParams {
 export interface AuthModuleOptions {
     /** Server URL for API requests. */
     serverUrl: string;
-    /** Optional base URL for the app (used for login redirects). */
-    appBaseUrl?: string;
+    /** Base URL for the app (used for login redirects). */
+    appBaseUrl: string;
 }
 /**
  * Authentication module for managing user authentication and authorization. The module automatically stores tokens in local storage when available and manages authorization headers for API requests.
@@ -171,6 +171,32 @@ export interface AuthModule {
      * ```
      */
     redirectToLogin(nextUrl: string): void;
+    /**
+     * Redirects the user to a third-party authentication provider's login page.
+     *
+     * Initiates an OAuth login flow with one of the built-in providers. Requires a browser environment and can't be used in the backend.
+     *
+     * Supported providers:
+     * - `'google'` - {@link https://developers.google.com/identity/protocols/oauth2 | Google OAuth}. Enabled by default.
+     * - `'microsoft'` - {@link https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow | Microsoft OAuth}. Enable Microsoft in your app's authentication settings before specifying this provider.
+     * - `'facebook'` - {@link https://developers.facebook.com/docs/facebook-login | Facebook Login}. Enable this in your app's authentication settings before using.
+     *
+     * @param provider - The authentication provider to use: `'google'`, `'microsoft'`, or `'facebook'`.
+     * @param fromUrl - URL to redirect to after successful authentication. Defaults to `'/'`.
+     *
+     * @example
+     * ```typescript
+     * // Login with Google and return to current page
+     * base44.auth.loginWithProvider('google', window.location.pathname);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Login with Microsoft and redirect to dashboard
+     * base44.auth.loginWithProvider('microsoft', '/dashboard');
+     * ```
+     */
+    loginWithProvider(provider: string, fromUrl?: string): void;
     /**
      * Logs out the current user.
      *

package/dist/modules/connectors.types.d.ts

@@ -1,7 +1,14 @@
+/**
+ * Registry of connector integration types.
+ * Augment this interface to enable autocomplete for connector integration types.
+ */
+export interface ConnectorIntegrationTypeRegistry {
+}
 /**
  * The type of external integration/connector, such as `'googlecalendar'`, `'slack'`, or `'github'`.
+ * Uses registry keys if augmented, otherwise falls back to string.
  */
-export type ConnectorIntegrationType = string;
+export type ConnectorIntegrationType = keyof ConnectorIntegrationTypeRegistry extends never ? string : keyof ConnectorIntegrationTypeRegistry;
 /**
  * Response from the connectors access token endpoint.
  */
@@ -11,9 +18,7 @@ export interface ConnectorAccessTokenResponse {
 /**
  * Connectors module for managing OAuth tokens for external services.
  *
- * This module allows you to retrieve OAuth access tokens for external services
- * that the app has connected to. Use these tokens to make API
- * calls to external services.
+ * This module allows you to retrieve OAuth access tokens for external services that the app has connected to. Connectors are app-scoped. When an app builder connects an integration like Google Calendar or Slack, all users of the app share that same connection.
  *
  * Unlike the integrations module that provides pre-built functions, connectors give you
  * raw OAuth tokens so you can call external service APIs directly with full control over
@@ -26,9 +31,9 @@ export interface ConnectorsModule {
     /**
      * Retrieves an OAuth access token for a specific external integration type.
      *
-     * Returns the OAuth token string for an external service that the app
-     * has connected to. You can then use this token to make authenticated API calls
-     * to that external service.
+     * Returns the OAuth token string for an external service that an app builder
+     * has connected to. This token represents the connected app builder's account
+     * and can be used to make authenticated API calls to that external service on behalf of the app.
      *
      * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, or `'github'`.
      * @returns Promise resolving to the access token string.

package/dist/modules/custom-integrations.types.d.ts

@@ -1,5 +1,6 @@
 /**
  * Parameters for calling a custom integration endpoint.
+ * @internal
  */
 export interface CustomIntegrationCallParams {
     /**
@@ -7,21 +8,17 @@ export interface CustomIntegrationCallParams {
      */
     payload?: Record<string, any>;
     /**
-     * Path parameters to substitute in the URL (e.g., `{ owner: "user", repo: "repo" }`).
+     * Path parameters to substitute in the URL. For example, `{ owner: "user", repo: "repo" }`.
      */
     pathParams?: Record<string, string>;
     /**
      * Query string parameters to append to the URL.
      */
     queryParams?: Record<string, any>;
-    /**
-     * Additional headers to send with this specific request.
-     * These are merged with the integration's configured headers.
-     */
-    headers?: Record<string, string>;
 }
 /**
  * Response from a custom integration call.
+ * @internal
  */
 export interface CustomIntegrationCallResponse {
     /**
@@ -39,60 +36,17 @@ export interface CustomIntegrationCallResponse {
     data: any;
 }
 /**
- * Module for calling custom workspace-level API integrations.
- *
- * Custom integrations allow workspace administrators to connect any external API
- * by importing an OpenAPI specification. Apps in the workspace can then call
- * these integrations using this module.
- *
- * Unlike the built-in integrations (like `Core`), custom integrations:
- * - Are defined per-workspace by importing OpenAPI specs
- * - Use a slug-based identifier instead of package names
- * - Proxy requests through Base44's backend (credentials never exposed to frontend)
- *
- * @example
- * ```typescript
- * // Call a custom GitHub integration
- * const response = await base44.integrations.custom.call(
- *   "github",        // integration slug (defined by workspace admin)
- *   "listIssues",    // operation ID from the OpenAPI spec
- *   {
- *     pathParams: { owner: "myorg", repo: "myrepo" },
- *     queryParams: { state: "open", per_page: 100 }
- *   }
- * );
+ * Module for calling custom pre-configured API integrations.
  *
- * if (response.success) {
- *   console.log("Issues:", response.data);
- * } else {
- *   console.error("API returned error:", response.status_code);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Call with request body payload
- * const response = await base44.integrations.custom.call(
- *   "github",
- *   "createIssue",
- *   {
- *     pathParams: { owner: "myorg", repo: "myrepo" },
- *     payload: {
- *       title: "Bug report",
- *       body: "Something is broken",
- *       labels: ["bug"]
- *     }
- *   }
- * );
- * ```
+ * Custom integrations allow workspace administrators to connect any external API by importing an OpenAPI specification. Apps in the workspace can then call these integrations using this module.
  */
 export interface CustomIntegrationsModule {
     /**
      * Call a custom integration endpoint.
      *
-     * @param slug - The integration's unique identifier (slug), as defined by the workspace admin.
-     * @param operationId - The operation ID from the OpenAPI spec (e.g., "listIssues", "getUser").
-     * @param params - Optional parameters including payload, pathParams, queryParams, and headers.
+     * @param slug - The integration's unique identifier, as defined by the workspace admin.
+     * @param operationId - The endpoint in `method:path` format. For example, `"get:/contacts"`, or `"post:/users/{id}"`. The method is the HTTP verb in lowercase and the path matches the OpenAPI specification.
+     * @param params - Optional parameters including payload, pathParams, and queryParams.
      * @returns Promise resolving to the integration call response.
      *
      * @throws {Error} If slug is not provided.
@@ -100,6 +54,36 @@ export interface CustomIntegrationsModule {
      * @throws {Base44Error} If the integration or operation is not found (404).
      * @throws {Base44Error} If the external API call fails (502).
      * @throws {Base44Error} If the request times out (504).
+     *
+     * @example
+     * ```typescript
+     * // Call a custom CRM integration
+     * const response = await base44.integrations.custom.call(
+     *   "my-crm",
+     *   "get:/contacts",
+     *   { queryParams: { limit: 10 } }
+     * );
+     *
+     * if (response.success) {
+     *   console.log("Contacts:", response.data);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Call with path params and request body
+     * const response = await base44.integrations.custom.call(
+     *   "github",
+     *   "post:/repos/{owner}/{repo}/issues",
+     *   {
+     *     pathParams: { owner: "myorg", repo: "myrepo" },
+     *     payload: {
+     *       title: "Bug report",
+     *       body: "Something is broken"
+     *     }
+     *   }
+     * );
+     * ```
      */
     call(slug: string, operationId: string, params?: CustomIntegrationCallParams): Promise<CustomIntegrationCallResponse>;
 }

package/dist/modules/entities.types.d.ts

@@ -4,12 +4,14 @@
 export type RealtimeEventType = "create" | "update" | "delete";
 /**
  * Payload received when a realtime event occurs.
+ *
+ * @typeParam T - The entity type for the data field. Defaults to `any`.
  */
-export interface RealtimeEvent {
+export interface RealtimeEvent<T = any> {
     /** The type of change that occurred */
     type: RealtimeEventType;
     /** The entity data */
-    data: any;
+    data: T;
     /** The unique identifier of the affected entity */
     id: string;
     /** ISO 8601 timestamp of when the event occurred */
@@ -17,29 +19,108 @@ export interface RealtimeEvent {
 }
 /**
  * Callback function invoked when a realtime event occurs.
+ *
+ * @typeParam T - The entity type for the event data. Defaults to `any`.
+ */
+export type RealtimeCallback<T = any> = (event: RealtimeEvent<T>) => void;
+/**
+ * Result returned when deleting a single entity.
+ */
+export interface DeleteResult {
+    /** Whether the deletion was successful */
+    success: boolean;
+}
+/**
+ * Result returned when deleting multiple entities.
+ */
+export interface DeleteManyResult {
+    /** Whether the deletion was successful */
+    success: boolean;
+    /** Number of entities that were deleted */
+    deleted: number;
+}
+/**
+ * Result returned when importing entities from a file.
+ *
+ * @typeParam T - The entity type for imported records. Defaults to `any`.
  */
-export type RealtimeCallback = (event: RealtimeEvent) => void;
+export interface ImportResult<T = any> {
+    /** Status of the import operation */
+    status: "success" | "error";
+    /** Details message, e.g., "Successfully imported 3 entities with RLS enforcement" */
+    details: string | null;
+    /** Array of created entity objects when successful, or null on error */
+    output: T[] | null;
+}
 /**
- * Function returned from subscribe, call it to unsubscribe.
+ * Sort field type for entity queries.
+ *
+ * Supports ascending (no prefix or `'+'`) and descending (`'-'`) sorting.
+ *
+ * @typeParam T - The entity type to derive sortable fields from.
+ *
+ * @example
+ * ```typescript
+ * // Ascending sort (default)
+ * 'created_date'
+ * '+created_date'
+ *
+ * // Descending sort
+ * '-created_date'
+ * ```
  */
-export type Subscription = () => void;
+export type SortField<T> = (keyof T & string) | `+${keyof T & string}` | `-${keyof T & string}`;
+/**
+ * Fields added by the server to every entity record (id, dates, created_by, etc.).
+ */
+interface ServerEntityFields {
+    /** Unique identifier of the record */
+    id: string;
+    /** ISO 8601 timestamp when the record was created */
+    created_date: string;
+    /** ISO 8601 timestamp when the record was last updated */
+    updated_date: string;
+    /** Email of the user who created the record (may be hidden in some responses) */
+    created_by?: string | null;
+    /** ID of the user who created the record */
+    created_by_id?: string | null;
+    /** Whether the record is sample/seed data */
+    is_sample?: boolean;
+}
+/**
+ * Registry mapping entity names to their TypeScript types.
+ * Augment this interface with your entity schema (user-defined fields only).
+ */
+export interface EntityTypeRegistry {
+}
+/**
+ * Full record type for each entity: schema fields + server-injected fields (id, created_date, etc.).
+ */
+export type EntityRecord = {
+    [K in keyof EntityTypeRegistry]: EntityTypeRegistry[K] & ServerEntityFields;
+};
 /**
  * Entity handler providing CRUD operations for a specific entity type.
  *
  * Each entity in the app gets a handler with these methods for managing data.
+ *
+ * @typeParam T - The entity type. Defaults to `any` for backward compatibility.
  */
-export interface EntityHandler {
+export interface EntityHandler<T = any> {
     /**
      * Lists records with optional pagination and sorting.
      *
      * Retrieves all records of this type with support for sorting,
      * pagination, and field selection.
      *
+     * **Note:** The maximum limit is 5,000 items per request.
+     *
+     * @typeParam K - The fields to include in the response. Defaults to all fields.
      * @param sort - Sort parameter, such as `'-created_date'` for descending. Defaults to `'-created_date'`.
      * @param limit - Maximum number of results to return. Defaults to `50`.
      * @param skip - Number of results to skip for pagination. Defaults to `0`.
      * @param fields - Array of field names to include in the response. Defaults to all fields.
-     * @returns Promise resolving to an array of records.
+     * @returns Promise resolving to an array of records with selected fields.
      *
      * @example
      * ```typescript
@@ -66,13 +147,16 @@ export interface EntityHandler {
      * const fields = await base44.entities.MyEntity.list('-created_date', 10, 0, ['name', 'status']);
      * ```
      */
-    list(sort?: string, limit?: number, skip?: number, fields?: string[]): Promise<any>;
+    list<K extends keyof T = keyof T>(sort?: SortField<T>, limit?: number, skip?: number, fields?: K[]): Promise<Pick<T, K>[]>;
     /**
      * Filters records based on a query.
      *
      * Retrieves records that match specific criteria with support for
      * sorting, pagination, and field selection.
      *
+     * **Note:** The maximum limit is 5,000 items per request.
+     *
+     * @typeParam K - The fields to include in the response. Defaults to all fields.
      * @param query - Query object with field-value pairs. Each key should be a field name
      * from your entity schema, and each value is the criteria to match. Records matching all
      * specified criteria are returned. Field names are case-sensitive.
@@ -80,7 +164,7 @@ export interface EntityHandler {
      * @param limit - Maximum number of results to return. Defaults to `50`.
      * @param skip - Number of results to skip for pagination. Defaults to `0`.
      * @param fields - Array of field names to include in the response. Defaults to all fields.
-     * @returns Promise resolving to an array of filtered records.
+     * @returns Promise resolving to an array of filtered records with selected fields.
      *
      * @example
      * ```typescript
@@ -122,7 +206,7 @@ export interface EntityHandler {
      * );
      * ```
      */
-    filter(query: Record<string, any>, sort?: string, limit?: number, skip?: number, fields?: string[]): Promise<any>;
+    filter<K extends keyof T = keyof T>(query: Partial<T>, sort?: SortField<T>, limit?: number, skip?: number, fields?: K[]): Promise<Pick<T, K>[]>;
     /**
      * Gets a single record by ID.
      *
@@ -138,7 +222,7 @@ export interface EntityHandler {
      * console.log(record.name);
      * ```
      */
-    get(id: string): Promise<any>;
+    get(id: string): Promise<T>;
     /**
      * Creates a new record.
      *
@@ -158,7 +242,7 @@ export interface EntityHandler {
      * console.log('Created record with ID:', newRecord.id);
      * ```
      */
-    create(data: Record<string, any>): Promise<any>;
+    create(data: Partial<T>): Promise<T>;
     /**
      * Updates an existing record.
      *
@@ -187,7 +271,7 @@ export interface EntityHandler {
      * });
      * ```
      */
-    update(id: string, data: Record<string, any>): Promise<any>;
+    update(id: string, data: Partial<T>): Promise<T>;
     /**
      * Deletes a single record by ID.
      *
@@ -200,10 +284,10 @@ export interface EntityHandler {
      * ```typescript
      * // Delete a record
      * const result = await base44.entities.MyEntity.delete('entity-123');
-     * console.log('Deleted:', result);
+     * console.log('Deleted:', result.success);
      * ```
      */
-    delete(id: string): Promise<any>;
+    delete(id: string): Promise<DeleteResult>;
     /**
      * Deletes multiple records matching a query.
      *
@@ -221,10 +305,10 @@ export interface EntityHandler {
      *   status: 'completed',
      *   priority: 'low'
      * });
-     * console.log('Deleted:', result);
+     * console.log('Deleted:', result.deleted);
      * ```
      */
-    deleteMany(query: Record<string, any>): Promise<any>;
+    deleteMany(query: Partial<T>): Promise<DeleteManyResult>;
     /**
      * Creates multiple records in a single request.
      *
@@ -244,7 +328,7 @@ export interface EntityHandler {
      * ]);
      * ```
      */
-    bulkCreate(data: Record<string, any>[]): Promise<any>;
+    bulkCreate(data: Partial<T>[]): Promise<T[]>;
     /**
      * Imports records from a file.
      *
@@ -252,7 +336,7 @@ export interface EntityHandler {
      * The file format should match your entity structure. Requires a browser environment and can't be used in the backend.
      *
      * @param file - File object to import.
-     * @returns Promise resolving to the import result.
+     * @returns Promise resolving to the import result containing status, details, and created records.
      *
      * @example
      * ```typescript
@@ -261,19 +345,27 @@ export interface EntityHandler {
      *   const file = event.target.files?.[0];
      *   if (file) {
      *     const result = await base44.entities.MyEntity.importEntities(file);
-     *     console.log(`Imported ${result.count} records`);
+     *     if (result.status === 'success' && result.output) {
+     *       console.log(`Imported ${result.output.length} records`);
+     *     }
      *   }
      * };
      * ```
      */
-    importEntities(file: File): Promise<any>;
+    importEntities(file: File): Promise<ImportResult<T>>;
     /**
      * Subscribes to realtime updates for all records of this entity type.
      *
-     * Receives notifications whenever any record is created, updated, or deleted.
+     * Establishes a WebSocket connection to receive instant updates when any
+     * record is created, updated, or deleted. Returns an unsubscribe function
+     * to clean up the connection.
      *
-     * @param callback - Function called when an entity changes.
-     * @returns Unsubscribe function to stop listening.
+     * @param callback - Callback function called when an entity changes. The callback receives an event object with the following properties:
+     * - `type`: The type of change that occurred - `'create'`, `'update'`, or `'delete'`.
+     * - `data`: The entity data after the change.
+     * - `id`: The unique identifier of the affected entity.
+     * - `timestamp`: ISO 8601 timestamp of when the event occurred.
+     * @returns Unsubscribe function to stop receiving updates.
      *
      * @example
      * ```typescript
@@ -282,12 +374,24 @@ export interface EntityHandler {
      *   console.log(`Task ${event.id} was ${event.type}d:`, event.data);
      * });
      *
-     * // Later, unsubscribe
+     * // Later, clean up the subscription
      * unsubscribe();
      * ```
      */
-    subscribe(callback: RealtimeCallback): Subscription;
+    subscribe(callback: RealtimeCallback<T>): () => void;
 }
+/**
+ * Typed entities module - maps registry keys to typed handlers (full record type).
+ */
+type TypedEntitiesModule = {
+    [K in keyof EntityTypeRegistry]: EntityHandler<EntityRecord[K]>;
+};
+/**
+ * Dynamic entities module - allows any entity name with untyped handler.
+ */
+type DynamicEntitiesModule = {
+    [entityName: string]: EntityHandler<any>;
+};
 /**
  * Entities module for managing app data.
  *
@@ -321,18 +425,5 @@ export interface EntityHandler {
  * const allUsers = await base44.asServiceRole.entities.User.list();
  * ```
  */
-export interface EntitiesModule {
-    /**
-     * Access any entity by name.
-     *
-     * Use this to access entities defined in the app.
-     *
-     * @example
-     * ```typescript
-     * // Access entities dynamically
-     * base44.entities.MyEntity
-     * base44.entities.AnotherEntity
-     * ```
-     */
-    [entityName: string]: EntityHandler;
-}
+export type EntitiesModule = TypedEntitiesModule & DynamicEntitiesModule;
+export {};

package/dist/modules/functions.types.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Registry of function names.
+ * Augment this interface to enable autocomplete for function names.
+ */
+export interface FunctionNameRegistry {
+}
+/**
+ * Function name type - uses registry keys if augmented, otherwise string.
+ */
+export type FunctionName = keyof FunctionNameRegistry extends never ? string : keyof FunctionNameRegistry;
 /**
  * Functions module for invoking custom backend functions.
  *
@@ -46,5 +56,5 @@ export interface FunctionsModule {
      * };
      * ```
      */
-    invoke(functionName: string, data: Record<string, any>): Promise<any>;
+    invoke(functionName: FunctionName, data?: Record<string, any>): Promise<any>;
 }