@rushdb/javascript-sdk 0.17.0 → 1.0.0

package/README.md

@@ -2,96 +2,88 @@
 
 ![RushDB Logo](https://raw.githubusercontent.com/rush-db/rushdb/main/rushdb-logo.svg)
 
-# RushDB SDK for JavaScript and TypeScript
+# 🚀 RushDB SDK for JavaScript and TypeScript
+
+### The Modern Graph Database Client for Web & Node.js
 
 [![NPM Version](https://img.shields.io/npm/v/%40rushdb%2Fjavascript-sdk)](https://www.npmjs.com/package/@rushdb/javascript-sdk)
 [![NPM License](https://img.shields.io/npm/l/%40rushdb%2Fjavascript-sdk)](#license "Go to license section")
-
-![NPM Downloads](https://img.shields.io/npm/dw/%40rushdb%2Fjavascript-sdk)
-![npm bundle size](https://img.shields.io/bundlephobia/minzip/%40rushdb%2Fjavascript-sdk)
-
+[![NPM Downloads](https://img.shields.io/npm/dw/%40rushdb%2Fjavascript-sdk)](https://www.npmjs.com/package/@rushdb/javascript-sdk)
+[![npm bundle size](https://img.shields.io/bundlephobia/minzip/%40rushdb%2Fjavascript-sdk)](https://bundlephobia.com/package/@rushdb/javascript-sdk)
 
 [![Made with Node](https://img.shields.io/badge/dynamic/json?label=node&query=%24.engines%5B%22node%22%5D&url=https%3A%2F%2Fraw.githubusercontent.com%2Frush-db%2Frushdb%2Fmain%2Fpackage.json)](https://nodejs.org "Go to Node.js homepage")
 [![Package - Typescript](https://img.shields.io/github/package-json/dependency-version/rush-db/rushdb/dev/typescript?logo=typescript&logoColor=white)](https://www.npmjs.com/package/typescript "Go to TypeScript on NPM")
 
-[Homepage](https://rushdb.com) — [Blog](https://rushdb.com/blog) — [Platform](https://app.rushdb.com) — [Docs](https://docs.rushdb.com) — [Examples](https://github.com/rush-db/examples)
+[🌐 Website](https://rushdb.com) • [📖 Documentation](https://docs.rushdb.com) • [☁️ Cloud Platform](https://app.rushdb.com) • [🔍 Examples](https://github.com/rush-db/examples)
 </div>
 
-## Highlights
+## ✨ Highlights
 
 ---
-> **✨ No Configuration Needed**: Plug-and-play design requires no setup or configuration.
-
-> **🤖 Automatic Type Inference**: Enjoy seamless type safety with automatic TypeScript inference.
-
-> **↔️ Isomorphic Architecture**: Fully compatible with both server and browser environments.
-
-> **🏋️ Zero Dependencies**: Lightweight and efficient with no external dependencies.
 
+- **🔌 No Configuration Needed**: Plug-and-play design requires minimal setup to get started
+- **🛡️ Automatic Type Inference**: Enjoy seamless type safety with automatic TypeScript inference
+- **🔄 Isomorphic Architecture**: Fully compatible with both server and browser environments
+- **⚡ Zero Dependencies**: Lightweight (just 6.9KB gzipped) and efficient with no external dependencies
 
 
-## Installation
+## 📦 Installation
 
 ---
-NPM:
 ```bash
+# NPM
 npm install @rushdb/javascript-sdk
-```
 
-YARN:
-```bash
+# YARN
 yarn add @rushdb/javascript-sdk
-```
 
-PNPM:
-```bash
-pnmp add @rushdb/javascript-sdk
+# PNPM
+pnpm add @rushdb/javascript-sdk
 ```
 
 
-## Usage
+## 🚀 Usage
 
 ---
 
-1. **Obtain API Token**: Grab one from the [Dashboard](https://app.rushdb.com).
+1. **Obtain API Token**: Grab one from the [RushDB Cloud Dashboard](https://app.rushdb.com).
 2. **Build anything**: Easily push, search, and manage relationships within your data.
 
-### TLDR;
+### Quick Example
 ```ts
-import RushDB, { Model } from '@rushdb/javascript-sdk'
+import RushDB from '@rushdb/javascript-sdk';
 
 // Setup SDK
-const db = new RushDB("API_TOKEN", {
-  // This is the default URL; no need to provide it unless overriding.
-  url: "https://api.rushdb.com", 
-});
+const db = new RushDB("API_TOKEN");
+// Default URL is "https://api.rushdb.com". See SDK Configuration for more options.
 
-// Push any data, and RushDB will automatically flatten it into Records 
+// Push any data, and RushDB will automatically flatten it into Records
 // and establish relationships between them accordingly.
-await db.records.createMany("COMPANY", {
-  name: 'Google LLC',
-  address: '1600 Amphitheatre Parkway, Mountain View, CA 94043, USA',
-  foundedAt: '1998-09-04T00:00:00.000Z',
-  rating: 4.9,
-  DEPARTMENT: [{
-    name: 'Research & Development',
-    description:
-        'Innovating and creating advanced technologies for AI, cloud computing, and consumer devices.',
-    PROJECT: [{
-      name: 'Bard AI',
-      description:
-          'A state-of-the-art generative AI model designed for natural language understanding and creation.',
-      active: true,
-      budget: 1200000000,
-      EMPLOYEE: [{
-        name: 'Jeff Dean',
-        position: 'Head of AI Research',
-        email: 'jeff@google.com',
-        dob: '1968-07-16T00:00:00.000Z',
-        salary: 3000000
+await db.records.createMany({
+  label: "COMPANY",
+  payload: {
+    name: 'Google LLC',
+    address: '1600 Amphitheatre Parkway, Mountain View, CA 94043, USA',
+    foundedAt: '1998-09-04T00:00:00.000Z',
+    rating: 4.9,
+    DEPARTMENT: [{
+      name: 'Research & Development',
+      description: 'Innovating and creating advanced technologies for AI, cloud computing, and consumer devices.',
+      PROJECT: [{
+        name: 'Bard AI',
+        description: 'A state-of-the-art generative AI model designed for natural language understanding and creation.',
+        active: true,
+        budget: 1200000000,
+        EMPLOYEE: [{
+          name: 'Jeff Dean',
+          position: 'Head of AI Research',
+          email: 'jeff@google.com',
+          dob: '1968-07-16T00:00:00.000Z',
+          salary: 3000000
+        }]
       }]
     }]
-  }]
+  }
 })
 
 
@@ -110,7 +102,8 @@ const matchedEmployees = await db.records.find({
   }
 })
 
-const company = await db.records.findUniq('COMPANY', {
+const company = await db.records.findUniq({
+  labels: ['COMPANY'],
   where: {
     name: 'Google LLC'
   }
@@ -120,6 +113,30 @@ const company = await db.records.findUniq('COMPANY', {
 await company.attach(matchedEmployees, { type: "WORKING_AT" })
 ```
 
+## ⚙️ SDK Configuration
+---
+The SDK is designed to be flexible. You can provide configuration options when initializing `RushDB` to customize its behavior, such as the API endpoint or request timeouts.
+
+```typescript
+import RushDB from '@rushdb/javascript-sdk';
+
+// Example: Initialize with a custom URL and timeout
+const db = new RushDB('API_TOKEN', {
+  url: 'http://your-custom-rushdb-server.com', // Default is 'https://api.rushdb.com'
+  timeout: 30000 // 30 seconds
+});
+```
+
+The `RushDB` constructor accepts an optional second argument for configuration. Key options include:
+- `url`: The complete URL to the RushDB API.
+- Alternatively, `host`, `port`, and `protocol` can be specified individually.
+- `timeout`: Request timeout in milliseconds (default: 10000).
+- `httpClient`: For advanced use cases, provide a custom HTTP client implementation.
+- `logger`: Implement a custom logger for debugging or monitoring.
+- `options.allowForceDelete`: Set to `true` to enable deleting all records without specifying criteria (defaults to `false` for safety).
+
+For a comprehensive guide on all available configuration options, please refer to the [SDK Configuration Documentation](https://docs.rushdb.com/typescript-sdk/introduction#sdk-configuration-options).
+
 <div align="center">
 <b>You're Awesome!</b>  🚀
 </div>
@@ -128,14 +145,13 @@ await company.attach(matchedEmployees, { type: "WORKING_AT" })
 
 <div align="center" style="margin-top: 20px">
 
-> Check the [Docs](https://docs.rushdb.com) and [Examples Repository](https://github.com/rush-db/examples) to learn more 🤓
-
+> 📚 Check the [Complete Documentation](https://docs.rushdb.com/typescript-sdk/introduction) and [Examples Repository](https://github.com/rush-db/examples) to learn more!
 
 </div>
 
 
-## Contributing
+## 🤝 Contributing
 
 ---
-See [CONTRIBUTING.md](CONTRIBUTING.md).
+We welcome contributions! See our [CONTRIBUTING.md](CONTRIBUTING.md) guide for details.
 

package/dist/api/api.d.ts

@@ -1,42 +1,283 @@
 import type { HttpClient } from '../network/HttpClient.js';
+import type { DBRecordTarget, RelationDetachOptions, RelationOptions, RelationTarget, Relation, DBRecordCreationOptions } from '../sdk/record.js';
 import type { SDKConfig } from '../sdk/types.js';
-import type { SearchQuery, Schema, PropertyValuesOptions } from '../types/index.js';
-import type { ApiResponse, RecordsApi } from './types.js';
+import type { SearchQuery, Schema, InferSchemaTypesWrite, MaybeArray, PropertyValuesOptions, PropertyDraft, Property, PropertyValuesData, AnyObject } from '../types/index.js';
+import type { ApiResponse } from './types.js';
 import { createFetcher } from '../network/index.js';
+import { DBRecordInstance, DBRecordsArrayInstance } from '../sdk/record.js';
 import { Transaction } from '../sdk/transaction.js';
-import { createApi } from './create-api.js';
 export declare class RestAPI {
-    api: ReturnType<typeof createApi>;
     fetcher: ReturnType<typeof createFetcher>;
-    records: RecordsApi;
+    options: SDKConfig['options'];
+    logger: SDKConfig['logger'];
     constructor(token?: string, config?: SDKConfig & {
         httpClient: HttpClient;
     });
-    relations: {
-        find: <S extends Schema = any>({ pagination, search, transaction }: {
-            pagination?: Pick<SearchQuery, "limit" | "skip">;
-            search?: SearchQuery<S>;
-            transaction?: Transaction | string;
-        }) => Promise<ApiResponse<import("../sdk/record.js").Relation[]>>;
+    _extractTargetIds(target: RelationTarget, operation: string): Array<string>;
+    /**
+     * API methods for managing database records
+     */
+    records: {
+        /**
+         * Attaches a relation between records
+         * @param source - The source record to create relation from
+         * @param target - The target record(s) to create relation to
+         * @param options - Optional relation configuration
+         * @param options.type - The type of relation to create
+         * @param options.direction - The direction of the relation
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response
+         */
+        attach: ({ source, target, options }: {
+            source: DBRecordTarget;
+            target: RelationTarget;
+            options?: RelationOptions;
+        }, transaction?: Transaction | string) => Promise<ApiResponse<{
+            message: string;
+        }>>;
+        /**
+         * Detaches (removes) a relation between records
+         * @param source - The source record to remove relation from
+         * @param target - The target record(s) to remove relation to
+         * @param options - Optional detach configuration
+         * @param options.typeOrTypes - The type(s) of relations to remove
+         * @param options.direction - The direction of relations to remove
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response
+         */
+        detach: ({ source, target, options }: {
+            source: DBRecordTarget;
+            target: RelationTarget;
+            options?: RelationDetachOptions;
+        }, transaction?: Transaction | string) => Promise<ApiResponse<{
+            message: string;
+        }>>;
+        /**
+         * Creates a new record in the database
+         * @param label - The label/type of the record
+         * @param data - The record data, either as a flat object or array of property drafts
+         * @param options - Optional write configuration
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to the created DBRecordInstance
+         * @throws Error if data is not a flat object and createMany should be used instead
+         */
+        create: <S extends Schema = any>({ label, data, options }: {
+            label: string;
+            data: InferSchemaTypesWrite<S> | Array<PropertyDraft>;
+            options?: Omit<DBRecordCreationOptions, "returnResult" | "capitalizeLabels" | "relationshipType">;
+        }, transaction?: Transaction | string) => Promise<DBRecordInstance<S>>;
+        /**
+         * Creates multiple records in a single operation
+         * @param data - Object containing label, options and data array or object for multiple records
+         * @param data.label - The label/type for all records
+         * @param data.options - Optional write configuration
+         * @param data.data - Array of record data to create
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to DBRecordsArrayInstance containing created records
+         */
+        createMany: <S extends Schema = any>(data: {
+            label: string;
+            data: MaybeArray<AnyObject>;
+            options?: DBRecordCreationOptions;
+        }, transaction?: Transaction | string) => Promise<DBRecordsArrayInstance<S>>;
+        /**
+         * Deletes records matching the search query
+         * @param searchQuery - Query to identify records to delete
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response
+         * @throws EmptyTargetError if query is empty and force delete is not allowed
+         */
+        delete: <S extends Schema = any>(searchQuery: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<{
+            message: string;
+        }>>;
+        /**
+         * Deletes record(s) by ID
+         * @param idOrIds - Single ID or array of IDs to delete
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response
+         */
+        deleteById: (idOrIds: MaybeArray<string>, transaction?: Transaction | string) => Promise<ApiResponse<{
+            message: string;
+        }>>;
+        /**
+         * Exports records matching the search query to CSV format
+         * @param searchQuery - Query to identify records to export
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response containing CSV data
+         */
+        export: <S extends Schema = any>(searchQuery: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<{
+            dateTime: string;
+            fileContent: string;
+        }>>;
+        /**
+         * Searches for records matching the query criteria
+         * @param searchQueryWithEntryPoint - Search query with optional entry point ID
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to DBRecordsArrayInstance containing matched records
+         */
+        find: <S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(searchQueryWithEntryPoint: Q & {
+            id?: string;
+        }, transaction?: Transaction | string) => Promise<DBRecordsArrayInstance<S, Q>>;
+        /**
+         * Retrieves record(s) by ID
+         * @param idOrIds - Single ID or array of IDs to retrieve
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to DBRecordInstance or DBRecordsArrayInstance depending on input
+         */
+        findById: <S extends Schema = Schema, Arg extends MaybeArray<string> = MaybeArray<string>, Result = Arg extends string[] ? DBRecordsArrayInstance<S, SearchQuery<S>> : DBRecordInstance<S, SearchQuery<S>>>(idOrIds: Arg, transaction?: Transaction | string) => Promise<Result>;
+        /**
+         * Finds a single record matching the search query
+         * @param searchQuery - Query to identify the record
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to DBRecordInstance
+         */
+        findOne: <S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(searchQuery: Q, transaction?: Transaction | string) => Promise<DBRecordInstance<S>>;
+        /**
+         * Finds a unique record matching the search query
+         * @param searchQuery - Query to identify the record
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to DBRecordInstance
+         * @throws NonUniqueResultError if multiple records match the query
+         */
+        findUniq: <S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(searchQuery: Q, transaction?: Transaction | string) => Promise<DBRecordInstance<S, Q>>;
+        /**
+         * Sets (overwrites) record data
+         * @param target - The record to update
+         * @param label - The label/type of the record
+         * @param data - The new record data
+         * @param options - Optional write configuration
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to updated DBRecordInstance
+         * @throws Error if data is not a flat object
+         */
+        set: <S extends Schema = any>({ target, label, data, options }: {
+            target: DBRecordTarget;
+            label: string;
+            data: InferSchemaTypesWrite<S> | Array<PropertyDraft>;
+            options?: Omit<DBRecordCreationOptions, "returnResult" | "capitalizeLabels" | "relationshipType">;
+        }, transaction?: Transaction | string) => Promise<DBRecordInstance<S, SearchQuery<S>>>;
+        /**
+         * Updates record data (partial update)
+         * @param target - The record to update
+         * @param label - The label/type of the record
+         * @param data - The partial record data to update
+         * @param options - Optional write configuration
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise resolving to updated DBRecordInstance
+         * @throws Error if data is not a flat object
+         */
+        update: <S extends Schema = any>({ target, label, data, options }: {
+            target: DBRecordTarget;
+            label: string;
+            data: Partial<InferSchemaTypesWrite<S>> | Array<PropertyDraft>;
+            options?: Omit<DBRecordCreationOptions, "returnResult" | "capitalizeLabels" | "relationshipType">;
+        }, transaction?: Transaction | string) => Promise<DBRecordInstance<S, SearchQuery<S>>>;
+    };
+    /**
+     * API methods for managing relations between records
+     */
+    relationships: {
+        /**
+         * Searches for relations matching the query criteria
+         * @param searchQuery - Query to identify relations
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response containing matched relations
+         */
+        find: <S extends Schema = any>(searchQuery: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<Relation[]>>;
     };
+    /**
+     * API methods for managing properties in the database
+     */
     properties: {
-        delete: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property>>;
-        find: <S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property[]>>;
-        findById: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property>>;
-        values: (id: string, options?: PropertyValuesOptions, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property & import("../types/value.js").PropertyValuesData>>;
+        /**
+         * Deletes a property by its ID
+         * @param id - The unique identifier of the property to delete
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response containing the deleted property
+         */
+        delete: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<Property>>;
+        /**
+         * Searches for properties based on the provided query
+         * @param searchQuery - Query parameters to filter properties
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response containing an array of matching properties
+         */
+        find: <S extends Schema = any>(searchQuery: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<Property[]>>;
+        /**
+         * Retrieves a specific property by its ID
+         * @param id - The unique identifier of the property to retrieve
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response containing the requested property
+         */
+        findById: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<Property>>;
+        /**
+         * Retrieves values for a specific property
+         * @param id - The unique identifier of the property
+         * @param options - Optional parameters for pagination, sorting, and filtering
+         * @param options.sort - Sort direction for values ('asc' or 'desc')
+         * @param options.skip - Number of values to skip
+         * @param options.limit - Maximum number of values to return
+         * @param options.query - Filter query for values
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response containing the property and its values
+         */
+        values: (id: string, options?: PropertyValuesOptions, transaction?: Transaction | string) => Promise<ApiResponse<{
+            metadata?: string;
+            name: string;
+            type: import("../types/value.js").PropertyType;
+        } & {
+            id: string;
+        } & PropertyValuesData>>;
     };
+    /**
+     * API methods for managing labels in the database
+     */
     labels: {
-        find: <S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<Record<string, number>>>;
+        /**
+         * Searches for labels based on the provided query
+         * @param searchQuery - Query parameters to filter labels
+         * @param transaction - Optional transaction for atomic operations
+         * @returns Promise with the API response containing a record of label names and their counts
+         */
+        find: <S extends Schema = any>(searchQuery: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<Record<string, number>>>;
     };
+    /**
+     * API methods for managing database transactions
+     */
     tx: {
+        /**
+         * Begins a new database transaction
+         * @param config - Optional configuration object for the transaction
+         * @param config.ttl - Time-to-live in milliseconds for the transaction
+         * @returns A new Transaction instance that can be used for subsequent operations
+         * @throws If the transaction cannot be started
+         */
         begin: (config?: Partial<{
             ttl: number;
         }>) => Promise<Transaction>;
-        commit: (id: string) => Promise<ApiResponse<{
+        /**
+         * Commits a transaction, making its changes permanent
+         * @param tx - The ID of the transaction or Transaction instance to commit
+         * @returns An ApiResponse indicating success or failure of the commit
+         * @throws If the transaction cannot be committed or doesn't exist
+         */
+        commit: (tx: string | Transaction) => Promise<ApiResponse<{
             message: string;
         }>>;
-        get: (id: string) => Promise<Transaction>;
-        rollback: (id: string) => Promise<ApiResponse<{
+        /**
+         * Retrieves an existing transaction by its ID
+         * @param tx - The ID of the transaction or Transaction instance to retrieve
+         * @returns A Transaction instance representing the retrieved transaction
+         * @throws If the transaction doesn't exist or cannot be retrieved
+         */
+        get: (tx: string | Transaction) => Promise<Transaction>;
+        /**
+         * Rolls back a transaction, undoing all changes made within it
+         * @param tx - The ID of the transaction or Transaction instance to roll back
+         * @returns An ApiResponse indicating success or failure of the rollback
+         * @throws If the transaction cannot be rolled back or doesn't exist
+         */
+        rollback: (tx: string | Transaction) => Promise<ApiResponse<{
             message: string;
         }>>;
     };

package/dist/api/index.d.ts

@@ -1,3 +1,2 @@
-export { DBRecordsBatchDraft, DBRecordDraft } from '../sdk/record.js';
 export { RestAPI } from './api.js';
 export { ApiResponse } from './types.js';

package/dist/api/rest-api-proxy.d.ts

@@ -2,5 +2,5 @@ import type { RestAPI } from './api.js';
 export declare class RestApiProxy {
     protected apiProxy: RestAPI;
     constructor();
-    init(api: RestAPI, methodsWhiteList?: []): void;
+    init(api: RestAPI): void;
 }

package/dist/api/types.d.ts

@@ -1,65 +1,5 @@
-import type { DBRecordDraft, DBRecordInstance, DBRecordsArrayInstance, DBRecordsBatchDraft, DBRecordTarget, Relation, RelationDetachOptions, RelationOptions, RelationTarget } from '../sdk/record.js';
-import type { Transaction } from '../sdk/transaction.js';
-import type { InferSchemaTypesWrite, MaybeArray, Property, Schema, SearchQuery } from '../types/index.js';
 export type ApiResponse<T, E = Record<string, any>> = {
     data: T;
     success: boolean;
     total?: number;
 } & E;
-export type RecordsApi = {
-    attach(source: DBRecordTarget, target: RelationTarget, options?: RelationOptions, transaction?: Transaction | string): Promise<ApiResponse<{
-        message: string;
-    }>>;
-    create<S extends Schema = any>(label: string, data: InferSchemaTypesWrite<S>, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
-    create<S extends Schema = any>(labelOrData: DBRecordDraft | string, maybeDataOrTransaction?: Transaction | InferSchemaTypesWrite<S> | string, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
-    createMany<S extends Schema = any>(label: string, data: InferSchemaTypesWrite<S>[], transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
-    createMany<S extends Schema = any>(labelOrData: DBRecordsBatchDraft | string, maybeDataOrTransaction?: Transaction | MaybeArray<InferSchemaTypesWrite<S>> | string, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
-    delete<S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string): Promise<ApiResponse<{
-        message: string;
-    }>>;
-    deleteById(idOrIds: MaybeArray<string>, transaction?: Transaction | string): Promise<ApiResponse<{
-        message: string;
-    }>>;
-    detach(source: DBRecordTarget, target: RelationTarget, options?: RelationDetachOptions, transaction?: Transaction | string): Promise<ApiResponse<{
-        message: string;
-    }>>;
-    export<S extends Schema = any>(searchParams?: SearchQuery<S>, transaction?: Transaction | string): Promise<ApiResponse<{
-        dateTime: string;
-        fileContent: string;
-    }>>;
-    find<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(label: string, searchParams?: Q, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S, Q>>;
-    find<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(labelOrSearchParams: Q | string, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S, Q>>;
-    find<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(searchParams: Q, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S, Q>>;
-    findById<S extends Schema = any>(id: string, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
-    findById<S extends Schema = any>(ids: string[], transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
-    findOne<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(label: string, searchParams: Q & {
-        labels?: never;
-        limit?: never;
-        skip?: never;
-    }, transaction?: Transaction | string): Promise<DBRecordInstance<S, Q>>;
-    findOne<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(labelOrSearchParams: (Q & {
-        limit?: never;
-        skip?: never;
-    }) | string, transaction?: Transaction | string): Promise<DBRecordInstance<S, Q>>;
-    findOne<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(searchParams: Q & {
-        limit?: never;
-        skip?: never;
-    }, transaction?: Transaction | string): Promise<DBRecordInstance<S, Q>>;
-    findUniq<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(label: string, searchParams: Q & {
-        labels?: never;
-        limit?: never;
-        skip?: never;
-    }, transaction?: Transaction | string): Promise<DBRecordInstance<S, Q>>;
-    findUniq<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(labelOrSearchParams: (Q & {
-        limit?: never;
-        skip?: never;
-    }) | string, transaction?: Transaction | string): Promise<DBRecordInstance<S, Q>>;
-    findUniq<S extends Schema = any, Q extends SearchQuery<S> = SearchQuery<S>>(searchParams: Q & {
-        limit?: never;
-        skip?: never;
-    }, transaction?: Transaction | string): Promise<DBRecordInstance<S, Q>>;
-    properties(target: DBRecordTarget, transaction?: Transaction | string): Promise<ApiResponse<Property[]>>;
-    relations(target: DBRecordTarget, transaction?: Transaction | string): Promise<ApiResponse<Array<Relation>>>;
-    set<S extends Schema = any>(target: DBRecordTarget, data: DBRecordDraft | InferSchemaTypesWrite<S>, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
-    update<S extends Schema = any>(target: DBRecordTarget, data: DBRecordDraft | Partial<InferSchemaTypesWrite<S>>, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
-};

package/dist/api/utils.d.ts

@@ -1,44 +1,14 @@
 import type { DBRecordTarget } from '../sdk';
 import type { SDKConfig } from '../sdk/types.js';
-import type { PropertyType, PropertyValue, PropertyWithValue, SearchQuery, Schema } from '../types/index.js';
+import type { PropertyDraft } from '../types/index.js';
 import { Transaction } from '../sdk/transaction.js';
 export declare const buildTransactionHeader: (txId?: string) => {
     "x-transaction-id": string;
 } | undefined;
 export declare const isTransaction: (input: any) => input is Transaction | string;
-export declare const pickTransaction: (input: any) => string | Transaction | undefined;
 export declare const pickTransactionId: (input: any) => string | undefined;
-export declare const pickRecordId: (input: DBRecordTarget) => string | undefined;
-export declare const createSearchParams: <S extends Schema = Schema>(labelOrSearchParams?: SearchQuery<S> | string, searchParamsOrTransaction?: SearchQuery<S> | Transaction | string) => {
-    id?: string;
-    searchParams: SearchQuery<S>;
-};
 export declare const isUUID: (value: any) => boolean;
-export declare const arrayIsConsistent: (arr: Array<unknown>) => boolean;
-export declare const getValueParameters: (value: PropertyValue) => {
-    isEmptyArray: boolean;
-    isEmptyStringsArray: boolean;
-    isInconsistentArray: boolean;
-    isEmptyString?: undefined;
-} | {
-    isEmptyString: boolean;
-    isEmptyArray?: undefined;
-    isEmptyStringsArray?: undefined;
-    isInconsistentArray?: undefined;
-};
-export declare const suggestPropertyType: (value: PropertyValue) => PropertyType;
-export declare const prepareProperties: (data: Record<string, PropertyValue>, options?: {
-    suggestTypes: boolean;
-}) => PropertyWithValue[];
-export declare const normalizeRecord: ({ label, options, payload }: {
-    label: string;
-    options?: {
-        suggestTypes: boolean;
-    };
-    payload: Record<string, PropertyValue>;
-}) => {
-    label: string;
-    properties: PropertyWithValue[];
-};
+export declare const pickRecordId: (input: DBRecordTarget) => string | undefined;
+export declare const isPropertyDraft: (obj: any) => obj is PropertyDraft;
 export declare const buildUrl: (props: SDKConfig) => string;
 export declare const generateRandomId: (size?: number) => string;

package/dist/common/constants.d.ts

@@ -5,3 +5,5 @@ export declare const PROPERTY_TYPE_DATETIME: "datetime";
 export declare const PROPERTY_TYPE_BOOLEAN: "boolean";
 export declare const PROPERTY_TYPE_NUMBER: "number";
 export declare const PROPERTY_TYPE_NULL: "null";
+export declare const PROPERTY_TYPE_VECTOR: "vector";
+export declare const PROPERTY_TYPES: ("string" | "number" | "boolean" | "datetime" | "null" | "vector")[];

package/dist/common/utils.d.ts

@@ -1,7 +1,9 @@
 import type { PropertyValue } from '../types/index.js';
-export declare const isArray: (item: any) => item is any[];
+export declare const isArray: (item: any) => item is Array<any>;
 export declare const isObject: (input: unknown) => input is object;
 export declare const isEmptyObject: (input: unknown) => boolean;
-export declare const isObjectFlat: (input: any) => input is Record<string, PropertyValue>;
+export declare const isPrimitive: (value: unknown) => value is string | number | boolean | null;
+export declare const isPropertyValue: (value: any) => value is PropertyValue;
+export declare const isFlatObject: (input: any) => input is Record<string, PropertyValue>;
 export declare const isString: (input: any) => input is string;
 export declare const toBoolean: (value: any) => boolean;