@rushdb/javascript-sdk 0.1.0

package/types/api/create-api.d.ts

@@ -0,0 +1,67 @@
+import type { createFetcher } from '../network/index.js';
+import type { DBRecord, DBRecordTarget, Relation, RelationDetachOptions, RelationOptions } from '../sdk/record.js';
+import type { Transaction } from '../sdk/transaction.js';
+import type { Property, PropertyValuesData, SearchQuery, Schema, MaybeArray } from '../types/index.js';
+import type { ApiResponse } from './types.js';
+import { DBRecordsBatchDraft, DBRecordDraft } from '../sdk/record.js';
+export declare const createApi: (fetcher: ReturnType<typeof createFetcher>) => {
+    labels: {
+        find<S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string): Promise<ApiResponse<Record<string, number>>>;
+    };
+    properties: {
+        delete: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<Property>>;
+        find: <S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<Property[]>>;
+        findById: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<Property>>;
+        values: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<Property & PropertyValuesData>>;
+    };
+    records: {
+        attach: (source: DBRecordTarget, idOrIds: MaybeArray<string>, options?: RelationOptions, transaction?: Transaction | string) => Promise<ApiResponse<{
+            message: string;
+        }>>;
+        create<S extends Schema = any>(data: DBRecordDraft | S, transaction?: Transaction | string): Promise<ApiResponse<DBRecord<S> | undefined>>;
+        createMany<S extends Schema = any>(data: DBRecordsBatchDraft | S[], transaction?: Transaction | string): Promise<ApiResponse<DBRecord<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, idOrIds: MaybeArray<string>, 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>(params?: {
+            id?: string;
+            searchParams: SearchQuery<S>;
+        }, transaction?: Transaction | string): Promise<ApiResponse<DBRecord<S>[]>>;
+        findById<S extends Schema = any>(idOrIds: MaybeArray<string>, transaction?: Transaction | string): Promise<ApiResponse<DBRecord<S>[]>> | Promise<ApiResponse<DBRecord<S>>>;
+        findOne<S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string): Promise<ApiResponse<DBRecord<S>>>;
+        findUniq<S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string): Promise<ApiResponse<DBRecord<S>>>;
+        properties(target: string, transaction?: Transaction | string): Promise<ApiResponse<Property[]>>;
+        relations: (target: DBRecordTarget, transaction?: Transaction | string) => Promise<ApiResponse<Relation[]>>;
+        set<S extends Schema = any>(target: DBRecordTarget, data: DBRecordDraft | S, transaction?: Transaction | string): Promise<ApiResponse<DBRecord<S>>>;
+        update<S extends Schema = any>(target: DBRecordTarget, data: DBRecordDraft | S, transaction?: Transaction | string): Promise<ApiResponse<DBRecord<S>>>;
+    };
+    relations: {
+        find: <S extends Schema = any>(searchParams: SearchQuery<S>, pagination?: Pick<SearchQuery, "limit" | "skip">, transaction?: Transaction | string) => Promise<ApiResponse<Relation[]>>;
+    };
+    tx: {
+        begin(config?: Partial<{
+            ttl: number;
+        }>): Promise<ApiResponse<{
+            id: string;
+        }>>;
+        commit(id: string): Promise<ApiResponse<{
+            message: string;
+        }>>;
+        get(id: string): Promise<ApiResponse<{
+            id: string;
+        }>>;
+        rollback(id: string): Promise<ApiResponse<{
+            message: string;
+        }>>;
+    };
+};

package/types/api/index.d.ts

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

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

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

package/types/api/types.d.ts

@@ -0,0 +1,65 @@
+import type { DBRecordsBatchDraft, DBRecordDraft, DBRecordInstance, DBRecordTarget, DBRecordsArrayInstance, Relation, RelationDetachOptions, RelationOptions, RelationTarget } from '../sdk/record.js';
+import type { Transaction } from '../sdk/transaction.js';
+import type { Property, SearchQuery, Schema, InferSchemaTypesWrite, MaybeArray } 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>(label: string, searchParams?: SearchQuery<S>, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
+    find<S extends Schema = any>(labelOrSearchParams: SearchQuery<S> | string, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
+    find<S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
+    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>(label: string, searchParams: SearchQuery<S> & {
+        labels?: never;
+        limit?: never;
+        skip?: never;
+    }, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    findOne<S extends Schema = any>(labelOrSearchParams: (SearchQuery<S> & {
+        limit?: never;
+        skip?: never;
+    }) | string, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    findOne<S extends Schema = any>(searchParams: SearchQuery<S> & {
+        limit?: never;
+        skip?: never;
+    }, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    findUniq<S extends Schema = any>(label: string, searchParams: SearchQuery<S> & {
+        labels?: never;
+        limit?: never;
+        skip?: never;
+    }, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    findUniq<S extends Schema = any>(labelOrSearchParams: (SearchQuery<S> & {
+        limit?: never;
+        skip?: never;
+    }) | string, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    findUniq<S extends Schema = any>(searchParams: SearchQuery<S> & {
+        limit?: never;
+        skip?: never;
+    }, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    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/types/api/utils.d.ts

@@ -0,0 +1,43 @@
+import type { DBRecordTarget } from '../sdk';
+import type { UserProvidedConfig } from '../sdk/types.js';
+import type { PropertyType, PropertyValue, PropertyWithValue, SearchQuery, Schema } 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 buildUrl: (props: UserProvidedConfig) => string;

package/types/common/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const ISO_8601_FULL: RegExp;
+export declare const DEFAULT_TIMEOUT = 80000;
+export declare const PROPERTY_TYPE_STRING: "string";
+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";

package/types/common/utils.d.ts

@@ -0,0 +1,7 @@
+import type { PropertyValue } from '../types/index.js';
+export declare const isArray: (item: any) => item is 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 isString: (input: any) => input is string;
+export declare const toBoolean: (value: any) => boolean;

package/types/index.d.ts

@@ -0,0 +1,72 @@
+import type {
+  InferType,
+  DBRecord,
+  UserProvidedConfig,
+  Relation
+} from './sdk'
+
+import {
+  DBRecordsBatchDraft,
+  DBRecordDraft,
+  RestAPI,
+  ApiResponse
+} from './api'
+import { HttpClient, HttpClientResponse } from './network/HttpClient'
+import {
+  Model,
+  DBRecordInstance,
+  DBRecordsArrayInstance,
+  Transaction,
+  idToDate,
+  idToTimestamp,
+  EmptyTargetError,
+  UniquenessError,
+  NonUniqueResultError
+} from './sdk'
+import { Models, Schema } from './types'
+
+declare module '@rushdb/javascript-sdk' {
+  export namespace RushDB {}
+
+  export class RushDB extends RestAPI {
+    static RushDB: typeof RushDB
+
+    constructor(token?: string, config?: UserProvidedConfig)
+    public api: RestAPI
+
+    public registerModel<Model extends Model = Model>(model: Model): Model //Model<T['schema']>
+    public getModel(label: string): Model
+    public getModels(): Map<string, Model>
+    public getInstance(token: string, config?: UserProvidedConfig): RushDB
+    public toInstance<Schema extends Schema = Schema>(
+      record: DBRecord<Schema>
+    ): DBRecordInstance
+  }
+
+  export {
+    DBRecordsBatchDraft,
+    Relation,
+    ApiResponse,
+    InferType,
+    Model,
+    Models,
+    DBRecord,
+    DBRecordDraft,
+    DBRecordInstance,
+    DBRecordsArrayInstance,
+    RestAPI,
+    Schema,
+    Transaction,
+    HttpClient,
+    HttpClientResponse,
+    EmptyTargetError,
+    NonUniqueResultError,
+    UniquenessError,
+    idToDate,
+    idToTimestamp
+  }
+
+  export * from './types'
+
+  export default RushDB
+}

package/types/network/FetchHttpClient.d.ts

@@ -0,0 +1,26 @@
+import type { HttpClientInterface, HttpClientResponseInterface, MakeRequestConfig } from './HttpClient.js';
+import type { ResponseHeaders } from './types.js';
+import { HttpClient, HttpClientGenericResponse } from './HttpClient.js';
+/**
+ * HTTP client which uses a `fetch` function to issue requests.
+ *
+ * By default, relies on the global `fetch` function, but an optional function
+ * can be passed in. If passing in a function, it is expected to match the Web
+ * Fetch API. As an example, this could be the function provided by the
+ * node-fetch package (https://github.com/node-fetch/node-fetch).
+ */
+export declare class FetchHttpClient extends HttpClient implements HttpClientInterface {
+    private readonly _fetchFn;
+    constructor(fetchFn?: typeof fetch);
+    private static makeFetchWithRaceTimeout;
+    private static makeFetchWithAbortTimeout;
+    makeRequest(url: string, { headers, method, protocol, requestData, timeout }: MakeRequestConfig): Promise<HttpClientResponseInterface>;
+}
+export declare class FetchHttpClientResponse extends HttpClientGenericResponse implements HttpClientResponseInterface {
+    _res: Response;
+    constructor(res: Response);
+    getRawResponse(): Response;
+    toStream(streamCompleteCallback: () => void): ReadableStream<Uint8Array> | null;
+    toJSON(): Promise<any>;
+    static _transformHeadersToObject(headers: Headers): ResponseHeaders;
+}

package/types/network/HttpClient.d.ts

@@ -0,0 +1,48 @@
+import type { RequestData, RequestHeaders, ResponseHeaders } from './types.js';
+type TimeoutError = TypeError & {
+    code?: string;
+};
+export interface HttpClientInterface {
+    makeRequest: (url: string, config: MakeRequestConfig) => Promise<HttpClientResponseInterface>;
+}
+export interface MakeRequestConfig<T extends Record<string, any> = Record<string, any>> {
+    credentials?: RequestCredentials;
+    headers?: RequestHeaders;
+    method: string;
+    protocol?: string;
+    requestData?: RequestData;
+    timeout?: number;
+}
+export interface HttpClientResponseInterface {
+    getHeaders: () => ResponseHeaders;
+    getRawResponse: () => unknown;
+    getStatusCode: () => number;
+    toJSON: () => Promise<any>;
+    toStream: (streamCompleteCallback: () => void) => unknown;
+}
+export declare class HttpClient implements HttpClientInterface {
+    static CONNECTION_CLOSED_ERROR_CODES: string[];
+    static TIMEOUT_ERROR_CODE: string;
+    makeRequest(url: string, { headers, method, protocol, requestData, timeout }: MakeRequestConfig): Promise<HttpClientResponseInterface>;
+    static makeTimeoutError(): TimeoutError;
+}
+export declare class HttpClientGenericResponse implements HttpClientResponseInterface {
+    _statusCode: number;
+    _headers: ResponseHeaders;
+    constructor(statusCode: number, headers: ResponseHeaders);
+    getStatusCode(): number;
+    getHeaders(): ResponseHeaders;
+    getRawResponse(): unknown;
+    toStream(streamCompleteCallback: () => void): unknown;
+    toJSON(): any;
+}
+export declare class HttpClientResponse<T = unknown> implements HttpClientResponseInterface {
+    _res: T;
+    constructor(response: T);
+    getStatusCode(): number;
+    getHeaders(): ResponseHeaders;
+    getRawResponse(): unknown;
+    toStream(streamCompleteCallback: () => void): unknown;
+    toJSON(): any;
+}
+export {};

package/types/network/NodeHttpClient.d.ts

@@ -0,0 +1,16 @@
+import * as http_ from 'http';
+import * as https_ from 'https';
+import type { HttpClientResponseInterface, MakeRequestConfig } from './HttpClient.js';
+import { HttpClient, HttpClientGenericResponse } from './HttpClient.js';
+export declare class NodeHttpClient extends HttpClient {
+    _agent?: http_.Agent | https_.Agent | undefined;
+    constructor(agent?: http_.Agent | https_.Agent);
+    makeRequest(urlString: string, { headers, method, protocol, requestData, timeout }: MakeRequestConfig): Promise<HttpClientResponseInterface>;
+}
+export declare class NodeHttpClientResponse extends HttpClientGenericResponse implements HttpClientResponseInterface {
+    _res: http_.IncomingMessage;
+    constructor(res: http_.IncomingMessage);
+    getRawResponse(): http_.IncomingMessage;
+    toStream(streamCompleteCallback: () => void): http_.IncomingMessage;
+    toJSON(): any;
+}

package/types/network/index.d.ts

@@ -0,0 +1,6 @@
+import type { HttpClient, MakeRequestConfig } from './HttpClient.js';
+export declare const createFetcher: ({ httpClient, token, url }: {
+    httpClient: HttpClient;
+    token?: string;
+    url: string;
+}) => <Data extends Record<string, any> = Record<string, any>>(input: URL | string, { headers: initHeaders, ...init }: MakeRequestConfig<Data>) => Promise<Data>;

package/types/network/types.d.ts

@@ -0,0 +1,4 @@
+export type RequestData<T extends Record<string, any> = Record<string, any>> = T;
+export type RequestHeaders = Record<string, number | string | string[]>;
+export type ResponseHeaderValue = string | string[];
+export type ResponseHeaders = Record<string, ResponseHeaderValue>;

package/types/sdk/constants.d.ts

@@ -0,0 +1 @@
+export declare const ALLOWED_CONFIG_PROPERTIES: string[];

package/types/sdk/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class UniquenessError extends Error {
+    constructor(label: string, properties: any);
+}
+export declare class EmptyTargetError extends Error {
+    constructor(message: string);
+}
+export declare class NonUniqueResultError extends Error {
+    constructor(duplicateCount: number, searchParams: Record<string, any>);
+}

package/types/sdk/index.d.ts

@@ -0,0 +1,7 @@
+export * from './sdk.js';
+export * from './types.js';
+export * from './errors.js';
+export * from './transaction.js';
+export * from './utils.js';
+export * from './record.js';
+export * from './model.js';

package/types/sdk/model.d.ts

@@ -0,0 +1,72 @@
+import type { SearchQuery, Schema, FlattenTypes, InferSchemaTypesRead, InferSchemaTypesWrite, MaybeArray } from '../types/index.js';
+import type { DBRecord, DBRecordInstance, DBRecordsArrayInstance, RelationDetachOptions, RelationOptions, RelationTarget } from './record.js';
+import type { Transaction } from './transaction.js';
+import { RestApiProxy } from '../api/rest-api-proxy.js';
+type RushDBInstance = {
+    registerModel(model: Model): void;
+};
+export declare class Model<S extends Schema = any> extends RestApiProxy {
+    readonly label: string;
+    readonly schema: S;
+    constructor(modelName: string, schema: S, RushDBInstance?: RushDBInstance);
+    /** @description
+     * Type helper for a draft version of the schema.
+     * Represents a flat object containing only the record's own properties
+     * (defined by the schema), excluding system fields such as `__id`, `__label`,
+     * and `__proptypes`. This type does not yet have a representation on the
+     * database side.
+     */
+    readonly draft: InferType<Model<S>>;
+    /** @description
+     * Type helper for a fully-defined record with database representation.
+     * Similar to the draft, but includes all fields that come with the record's
+     * database-side representation, such as `__id`, `__label`, and `__proptypes`.
+     */
+    readonly record: DBRecord<S>;
+    /** @description
+     * Type helper for a single record instance.
+     * Extends the record by providing additional methods to operate on this specific
+     * record, such as saving, updating, or deleting it.
+     */
+    readonly recordInstance: DBRecordInstance<S>;
+    /** @description
+     * Type helper for an array of record instances.
+     * Similar to a single record instance but supports batch or bulk operations,
+     * allowing efficient management of multiple records simultaneously.
+     */
+    readonly recordsArrayInstance: DBRecordsArrayInstance<S>;
+    getLabel(): string;
+    find(params?: SearchQuery<S> & {
+        labels?: never;
+    }, transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
+    findOne(params?: SearchQuery<S> & {
+        labels?: never;
+        limit?: never;
+        skip?: never;
+    }, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    findById(id: string, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    findUniq(params?: SearchQuery<S> & {
+        labels?: never;
+        limit?: never;
+        skip?: never;
+    }, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    create(record: InferSchemaTypesWrite<S>, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    attach(sourceId: string, target: RelationTarget, options?: RelationOptions, transaction?: Transaction | string): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }, Record<string, any>>>;
+    detach(sourceId: string, target: RelationTarget, options?: RelationDetachOptions, transaction?: Transaction | string): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }, Record<string, any>>>;
+    private handleSetOrUpdate;
+    set(id: string, record: InferSchemaTypesWrite<S>, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    update(id: string, record: Partial<InferSchemaTypesWrite<S>>, transaction?: Transaction | string): Promise<DBRecordInstance<S>>;
+    createMany(records: InferSchemaTypesWrite<S>[], transaction?: Transaction | string): Promise<DBRecordsArrayInstance<S>>;
+    delete(searchParams: Omit<SearchQuery<S>, 'labels'>, transaction?: Transaction | string): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }, Record<string, any>>>;
+    deleteById(idOrIds: MaybeArray<string>, transaction?: Transaction | string): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }, Record<string, any>>>;
+}
+export type InferType<M extends Model<any> = Model<any>> = FlattenTypes<InferSchemaTypesRead<M['schema']>>;
+export {};

package/types/sdk/record.d.ts

@@ -0,0 +1,109 @@
+import type { AnyObject, PropertyType, PropertyValue, PropertyWithValue, SearchQuery, Schema, FlattenTypes, InferSchemaTypesRead, InferSchemaTypesWrite, MaybeArray, OptionalKeysRead, RequiredKeysRead } from '../types/index.js';
+import type { Transaction } from './transaction.js';
+import { RestApiProxy } from '../api/rest-api-proxy.js';
+type DBRecordInternalProps<S extends Schema = Schema> = {
+    readonly __id: string;
+    readonly __label: string;
+    readonly __proptypes?: FlattenTypes<{
+        [Key in RequiredKeysRead<S>]: S[Key]['type'];
+    } & {
+        [Key in OptionalKeysRead<S>]?: S[Key]['type'];
+    }>;
+};
+export type RecordProps<S extends Schema = Schema> = S extends S ? InferSchemaTypesRead<S> : {
+    [K in keyof S]?: S[K];
+};
+export type DBRecord<S extends Schema = Schema> = FlattenTypes<DBRecordInternalProps<S> & FlattenTypes<RecordProps<S>>>;
+export type DBRecordTarget = DBRecord<any> | DBRecordInstance<any> | string;
+export type RelationTarget = DBRecordsArrayInstance<any> | MaybeArray<DBRecord<any>> | MaybeArray<DBRecordInstance<any>> | MaybeArray<string>;
+export type Relation = {
+    sourceId: string;
+    sourceLabel: string;
+    targetId: string;
+    targetLabel: string;
+    type: string;
+};
+export type RelationDirection = 'in' | 'out';
+export type RelationOptions = {
+    direction?: RelationDirection;
+    type?: string;
+};
+export type RelationDetachOptions = {
+    direction?: RelationDirection;
+    typeOrTypes?: string | string[];
+};
+export declare class DBRecordsBatchDraft {
+    label: string;
+    options?: {
+        returnResult?: boolean;
+        suggestTypes?: boolean;
+    };
+    payload: MaybeArray<AnyObject>;
+    constructor({ label, options, payload }: {
+        label: string;
+        options?: {
+            returnResult?: boolean;
+            suggestTypes?: boolean;
+        };
+        payload: AnyObject;
+    });
+    toJson(): {
+        label: string;
+        options: {
+            returnResult?: boolean;
+            suggestTypes?: boolean;
+        } | undefined;
+        payload: MaybeArray<AnyObject>;
+    };
+}
+export declare class DBRecordDraft {
+    label: string;
+    properties?: Array<{
+        metadata?: string;
+        name: string;
+        type: PropertyType;
+        value: PropertyValue;
+        valueSeparator?: string;
+    }>;
+    constructor({ label, properties }: {
+        label: string;
+        properties?: Array<PropertyWithValue & {
+            metadata?: string;
+            valueSeparator?: string;
+        }>;
+        relation?: RelationOptions;
+    });
+    toJson(): {
+        label: string;
+        properties: {
+            metadata?: string;
+            name: string;
+            type: PropertyType;
+            value: PropertyValue;
+            valueSeparator?: string;
+        }[] | undefined;
+    };
+}
+export declare class DBRecordInstance<S extends Schema = Schema> extends RestApiProxy {
+    data?: DBRecord<S>;
+    searchParams?: SearchQuery<S>;
+    constructor(data?: DBRecord<S>, searchParams?: SearchQuery<S>);
+    delete(transaction?: Transaction | string): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }, Record<string, any>> | undefined>;
+    update<S extends Schema = Schema>(partialData: DBRecordDraft | Partial<InferSchemaTypesWrite<S>>, transaction?: Transaction | string): Promise<DBRecordInstance<S> | undefined>;
+    set<S extends Schema = Schema>(data: DBRecordDraft | InferSchemaTypesWrite<S>, transaction?: Transaction | string): Promise<DBRecordInstance<S> | undefined>;
+    attach(target: RelationTarget, options?: RelationOptions, transaction?: Transaction | string): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }, Record<string, any>> | undefined>;
+    detach(target: RelationTarget, options?: RelationDetachOptions, transaction?: Transaction | string): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }, Record<string, any>> | undefined>;
+}
+export declare class DBRecordsArrayInstance<S extends Schema = Schema> extends RestApiProxy {
+    data?: DBRecord<S>[];
+    total: number | undefined;
+    searchParams?: SearchQuery<S>;
+    constructor(data?: DBRecord<S>[], total?: number, searchParams?: SearchQuery<S>);
+}
+export {};