@rushdb/javascript-sdk 0.1.0

package/types/sdk/sdk.d.ts

@@ -0,0 +1,136 @@
+import type { HttpClient } from '../network/HttpClient.js';
+import type { Models, Schema } from '../types/index.js';
+import type { Model } from './model.js';
+import type { State, UserProvidedConfig } from './types.js';
+import { DBRecordInstance } from './record.js';
+export declare const initSDK: (httpClient: HttpClient) => {
+    new (token?: string, config?: UserProvidedConfig): {
+        state: State;
+        models: Map<string, Model>;
+        registerModel<M extends Model = Model<any>>(model: Model): Model<any>;
+        getModels(): Map<string, Model>;
+        getModel<Label extends keyof Models | string = never>(label: Label): Label extends keyof Models ? Model<Models[Label]> : Model | undefined;
+        toInstance<S extends Schema = Schema>(record: import("../types/utils.js").FlattenTypes<{
+            readonly __id: string;
+            readonly __label: string;
+            readonly __proptypes?: import("../types/utils.js").FlattenTypes<{ [Key in import("../types/schema.js").RequiredKeysRead<S>]: S[Key]["type"]; } & { [Key_1 in import("../types/schema.js").OptionalKeysRead<S>]?: S[Key_1]["type"] | undefined; }> | undefined;
+        } & import("../types/utils.js").FlattenTypes<import("./record.js").RecordProps<S>>>): DBRecordInstance<S>;
+        api: ReturnType<typeof import("../api/create-api.js").createApi>;
+        fetcher: ReturnType<typeof import("../network/index.js").createFetcher>;
+        records: import("../api/types.js").RecordsApi;
+        relations: {
+            find: <S extends Schema = any>({ pagination, search, transaction }: {
+                pagination?: Pick<import("../types/query.js").SearchQuery, "limit" | "skip">;
+                search?: import("../types/query.js").SearchQuery<S> | undefined;
+                transaction?: import("./transaction.js").Transaction | string;
+            }) => Promise<import("../api/types.js").ApiResponse<import("./record.js").Relation[]>>;
+        };
+        properties: {
+            delete: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property>>;
+            find: <S extends Schema = any>(searchParams: import("../types/query.js").SearchQuery<S>, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property[]>>;
+            findById: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property>>;
+            values: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property & import("../types/value.js").PropertyValuesData>>;
+        };
+        labels: {
+            find: <S extends Schema = any>(searchParams: import("../types/query.js").SearchQuery<S>, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<Record<string, number>>>;
+        };
+        tx: {
+            begin: (config?: Partial<{
+                ttl: number;
+            }>) => Promise<import("./transaction.js").Transaction>;
+            commit: (id: string) => Promise<import("../api/types.js").ApiResponse<{
+                message: string;
+            }>>;
+            get: (id: string) => Promise<import("./transaction.js").Transaction>;
+            rollback: (id: string) => Promise<import("../api/types.js").ApiResponse<{
+                message: string;
+            }>>;
+        };
+    };
+    instance: {
+        state: State;
+        models: Map<string, Model>;
+        registerModel<M extends Model = Model<any>>(model: Model): Model<any>;
+        getModels(): Map<string, Model>;
+        getModel<Label extends keyof Models | string = never>(label: Label): Label extends keyof Models ? Model<Models[Label]> : Model | undefined;
+        toInstance<S extends Schema = Schema>(record: import("../types/utils.js").FlattenTypes<{
+            readonly __id: string;
+            readonly __label: string;
+            readonly __proptypes?: import("../types/utils.js").FlattenTypes<{ [Key in import("../types/schema.js").RequiredKeysRead<S>]: S[Key]["type"]; } & { [Key_1 in import("../types/schema.js").OptionalKeysRead<S>]?: S[Key_1]["type"] | undefined; }> | undefined;
+        } & import("../types/utils.js").FlattenTypes<import("./record.js").RecordProps<S>>>): DBRecordInstance<S>;
+        api: ReturnType<typeof import("../api/create-api.js").createApi>;
+        fetcher: ReturnType<typeof import("../network/index.js").createFetcher>;
+        records: import("../api/types.js").RecordsApi;
+        relations: {
+            find: <S extends Schema = any>({ pagination, search, transaction }: {
+                pagination?: Pick<import("../types/query.js").SearchQuery, "limit" | "skip">;
+                search?: import("../types/query.js").SearchQuery<S> | undefined;
+                transaction?: import("./transaction.js").Transaction | string;
+            }) => Promise<import("../api/types.js").ApiResponse<import("./record.js").Relation[]>>;
+        };
+        properties: {
+            delete: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property>>;
+            find: <S extends Schema = any>(searchParams: import("../types/query.js").SearchQuery<S>, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property[]>>;
+            findById: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property>>;
+            values: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property & import("../types/value.js").PropertyValuesData>>;
+        };
+        labels: {
+            find: <S extends Schema = any>(searchParams: import("../types/query.js").SearchQuery<S>, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<Record<string, number>>>;
+        };
+        tx: {
+            begin: (config?: Partial<{
+                ttl: number;
+            }>) => Promise<import("./transaction.js").Transaction>;
+            commit: (id: string) => Promise<import("../api/types.js").ApiResponse<{
+                message: string;
+            }>>;
+            get: (id: string) => Promise<import("./transaction.js").Transaction>;
+            rollback: (id: string) => Promise<import("../api/types.js").ApiResponse<{
+                message: string;
+            }>>;
+        };
+    };
+    getInstance(): {
+        state: State;
+        models: Map<string, Model>;
+        registerModel<M extends Model = Model<any>>(model: Model): Model<any>;
+        getModels(): Map<string, Model>;
+        getModel<Label extends keyof Models | string = never>(label: Label): Label extends keyof Models ? Model<Models[Label]> : Model | undefined;
+        toInstance<S extends Schema = Schema>(record: import("../types/utils.js").FlattenTypes<{
+            readonly __id: string;
+            readonly __label: string;
+            readonly __proptypes?: import("../types/utils.js").FlattenTypes<{ [Key in import("../types/schema.js").RequiredKeysRead<S>]: S[Key]["type"]; } & { [Key_1 in import("../types/schema.js").OptionalKeysRead<S>]?: S[Key_1]["type"] | undefined; }> | undefined;
+        } & import("../types/utils.js").FlattenTypes<import("./record.js").RecordProps<S>>>): DBRecordInstance<S>;
+        api: ReturnType<typeof import("../api/create-api.js").createApi>;
+        fetcher: ReturnType<typeof import("../network/index.js").createFetcher>;
+        records: import("../api/types.js").RecordsApi;
+        relations: {
+            find: <S extends Schema = any>({ pagination, search, transaction }: {
+                pagination?: Pick<import("../types/query.js").SearchQuery, "limit" | "skip">;
+                search?: import("../types/query.js").SearchQuery<S> | undefined;
+                transaction?: import("./transaction.js").Transaction | string;
+            }) => Promise<import("../api/types.js").ApiResponse<import("./record.js").Relation[]>>;
+        };
+        properties: {
+            delete: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property>>;
+            find: <S extends Schema = any>(searchParams: import("../types/query.js").SearchQuery<S>, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property[]>>;
+            findById: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property>>;
+            values: (id: string, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<import("../types/value.js").Property & import("../types/value.js").PropertyValuesData>>;
+        };
+        labels: {
+            find: <S extends Schema = any>(searchParams: import("../types/query.js").SearchQuery<S>, transaction?: import("./transaction.js").Transaction | string) => Promise<import("../api/types.js").ApiResponse<Record<string, number>>>;
+        };
+        tx: {
+            begin: (config?: Partial<{
+                ttl: number;
+            }>) => Promise<import("./transaction.js").Transaction>;
+            commit: (id: string) => Promise<import("../api/types.js").ApiResponse<{
+                message: string;
+            }>>;
+            get: (id: string) => Promise<import("./transaction.js").Transaction>;
+            rollback: (id: string) => Promise<import("../api/types.js").ApiResponse<{
+                message: string;
+            }>>;
+        };
+    };
+};

package/types/sdk/transaction.d.ts

@@ -0,0 +1,11 @@
+import { RestApiProxy } from '../api/rest-api-proxy.js';
+export declare class Transaction extends RestApiProxy {
+    readonly id: string;
+    constructor(id: string);
+    rollback(): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }>>;
+    commit(): Promise<import("../api/types.js").ApiResponse<{
+        message: string;
+    }>>;
+}

package/types/sdk/types.d.ts

@@ -0,0 +1,19 @@
+import type { HttpClientInterface } from '../network/HttpClient.js';
+type ApiConnectionConfig = {
+    host: string;
+    port: number;
+    protocol: string;
+} | {
+    url: string;
+};
+export type State = {
+    debug: boolean;
+    timeout: number;
+    token?: string;
+} & Partial<ApiConnectionConfig>;
+type CommonUserProvidedConfig = {
+    httpClient?: HttpClientInterface;
+    timeout?: number;
+} & ApiConnectionConfig;
+export type UserProvidedConfig = CommonUserProvidedConfig;
+export {};

package/types/sdk/utils.d.ts

@@ -0,0 +1,9 @@
+import type { PropertyValue, Schema, InferSchemaTypesWrite } from '../types/index.js';
+import type { UserProvidedConfig } from './types.js';
+export declare const mergeDefaultsWithPayload: <S extends Schema = Schema>(schema: S, payload: Partial<InferSchemaTypesWrite<S>>) => Promise<InferSchemaTypesWrite<S>>;
+export declare const pickUniqFieldsFromRecord: <S extends Schema = Schema>(schema: S, data: Partial<InferSchemaTypesWrite<S>>) => Record<string, PropertyValue>;
+export declare const pickUniqFieldsFromRecords: <S extends Schema = Schema>(data: Partial<InferSchemaTypesWrite<S>>[], schema: S, label: string) => Record<string, PropertyValue[]>;
+export declare const parseConfig: (config?: Record<string, unknown>) => UserProvidedConfig;
+export declare function validateInteger(name: string, n: unknown, defaultVal?: number): number;
+export declare function idToTimestamp(id: string): number;
+export declare function idToDate(id: string): Date;

package/types/types/expressions.d.ts

@@ -0,0 +1,23 @@
+import type { PROPERTY_TYPE_BOOLEAN, PROPERTY_TYPE_DATETIME, PROPERTY_TYPE_NULL, PROPERTY_TYPE_NUMBER, PROPERTY_TYPE_STRING } from '../common/constants.js';
+import type { MaybeArray, RequireAtLeastOne } from './utils.js';
+import type { BooleanValue, DatetimeObject, DatetimeValue, NullValue, NumberValue, StringValue } from './value.js';
+export type DatetimeExpression = DatetimeValue | RequireAtLeastOne<Record<'$gt' | '$gte' | '$lt' | '$lte' | '$ne', DatetimeObject | DatetimeValue> & Record<'$in' | '$nin', Array<DatetimeObject | DatetimeValue>>>;
+export type BooleanExpression = BooleanValue | Record<'$ne', BooleanValue>;
+export type NullExpression = NullValue | Record<'$ne', NullValue>;
+export type NumberExpression = NumberValue | RequireAtLeastOne<Record<'$gt' | '$gte' | '$lt' | '$lte' | '$ne', NumberValue> & Record<'$in' | '$nin', Array<NumberValue>>>;
+export type StringExpression = StringValue | RequireAtLeastOne<Record<'$contains' | '$endsWith' | '$ne' | '$startsWith', StringValue> & Record<'$in' | '$nin', Array<StringValue>>>;
+export type PropertyExpression = BooleanExpression | DatetimeExpression | NullExpression | NumberExpression | StringExpression;
+export type PropertyExpressionByType = {
+    [PROPERTY_TYPE_BOOLEAN]: BooleanExpression;
+    [PROPERTY_TYPE_DATETIME]: DatetimeExpression;
+    [PROPERTY_TYPE_NULL]: NullExpression;
+    [PROPERTY_TYPE_NUMBER]: NumberExpression;
+    [PROPERTY_TYPE_STRING]: StringExpression;
+};
+export type LogicalGrouping<T> = Partial<{
+    $and: MaybeArray<T>;
+    $nor: MaybeArray<T>;
+    $not: MaybeArray<T>;
+    $or: MaybeArray<T>;
+    $xor: MaybeArray<T>;
+}>;

package/types/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './value.js';
+export * from './query.js';
+export * from './utils.js';
+export * from './schema.js';
+export * from './expressions.js';

package/types/types/query.d.ts

@@ -0,0 +1,102 @@
+import type { RelationOptions } from '../sdk/index.js';
+import type { BooleanExpression, PropertyExpression, PropertyExpressionByType, DatetimeExpression, LogicalGrouping, NullExpression, NumberExpression, StringExpression } from './expressions.js';
+import type { Schema } from './schema.js';
+import type { MaybeArray, RequireAtLeastOne } from './utils.js';
+export type Relation = RelationOptions | string;
+export type Related = {
+    [Key in keyof Models]?: {
+        $alias?: string;
+        $relation?: Relation;
+    } & Where<Models[Key]>;
+};
+export type LogicalExpressionValue<T = PropertyExpression & Related> = AndExpression<T> | NorExpression<T> | NotExpression<T> | OrExpression<T> | T | XorExpression<T>;
+export type AndExpression<T = PropertyExpression & Related> = {
+    $and: MaybeArray<LogicalExpressionValue<T>>;
+};
+export type OrExpression<T = PropertyExpression & Related> = {
+    $or: MaybeArray<LogicalExpressionValue<T>>;
+};
+export type NotExpression<T = PropertyExpression & Related> = {
+    $not: MaybeArray<LogicalExpressionValue<T>>;
+};
+export type XorExpression<T = PropertyExpression & Related> = {
+    $xor: MaybeArray<LogicalExpressionValue<T>>;
+};
+export type NorExpression<T = PropertyExpression & Related> = {
+    $nor: MaybeArray<LogicalExpressionValue<T>>;
+};
+export type LogicalExpression<T = PropertyExpression & Related> = RequireAtLeastOne<AndExpression<T> & OrExpression<T> & NotExpression<T> & XorExpression<T> & NorExpression<T>>;
+type MaybeLogicalExpression<T> = LogicalExpression<T> | T;
+export type IdExpression = MaybeLogicalExpression<{
+    $id?: LogicalExpression<StringExpression> | StringExpression;
+} & Related>;
+export type Expression<S extends Schema = Schema> = IdExpression | (S extends Schema ? {
+    [Key in keyof S]?: MaybeLogicalExpression<PropertyExpressionByType[S[Key]['type']]>;
+} : {
+    [Key in keyof S]?: S[Key] extends MaybeArray<number> ? MaybeLogicalExpression<NumberExpression> : S[Key] extends MaybeArray<boolean> ? MaybeLogicalExpression<BooleanExpression> : S[Key] extends MaybeArray<string> ? MaybeLogicalExpression<DatetimeExpression> | MaybeLogicalExpression<StringExpression> : S[Key] extends MaybeArray<null> ? MaybeLogicalExpression<NullExpression> : LogicalExpression | Partial<PropertyExpression>;
+});
+export type Where<S extends Schema = Schema> = ((Expression<S> & Related) & LogicalGrouping<Expression<S> & Related>) | LogicalGrouping<Expression<S> & Related>;
+export type Order<S extends Schema = Schema> = 'asc' | 'desc' | Partial<Record<keyof S, 'asc' | 'desc'>>;
+export type AggregateCollectFn = {
+    alias: string;
+    field?: string;
+    fn: 'collect';
+    limit?: number;
+    orderBy?: Order;
+    skip?: number;
+    uniq?: true;
+};
+export type AggregateCollectNestedFn = Omit<AggregateCollectFn, 'field'> & {
+    aggregate?: {
+        [field: string]: AggregateCollectNestedFn;
+    };
+};
+export type AggregateFn<S extends Schema = Schema> = {
+    alias: string;
+    field: string;
+    fn: 'avg';
+    precision?: number;
+} | {
+    alias: string;
+    field: string;
+    fn: 'max';
+} | {
+    alias: string;
+    field: string;
+    fn: 'min';
+} | {
+    alias: string;
+    field: string;
+    fn: 'sum';
+} | {
+    alias: string;
+    field?: string;
+    fn: 'count';
+    uniq?: true;
+} | AggregateCollectFn;
+export type Aggregate = {
+    [field: string]: AggregateCollectNestedFn;
+} | {
+    [field: string]: AggregateFn | string;
+};
+export type WhereClause<S extends Schema = Schema> = {
+    where?: Where<S>;
+};
+export type PaginationClause = {
+    limit?: number;
+    skip?: number;
+};
+export type SearchQueryLabelsClause = {
+    labels?: string[];
+};
+export type OrderClause<S extends Schema = Schema> = {
+    orderBy?: Order<S>;
+};
+export type AggregateClause = {
+    aggregate?: Aggregate;
+};
+export type SearchQuery<S extends Schema = any> = SearchQueryLabelsClause & PaginationClause & OrderClause<S> & WhereClause<S> & AggregateClause;
+/** Redeclare Models type in order to have suggestions over related records fields **/
+export interface Models {
+}
+export {};

package/types/types/schema.d.ts

@@ -0,0 +1,48 @@
+import type { FlattenTypes, MaybePromise } from './utils.js';
+import type { DatetimeObject, PropertyType, PropertyValue } from './value.js';
+export type SchemaDefaultValue<T extends PropertyType = PropertyType> = MaybePromise<PropertyValue<T>>;
+export type SchemaField<T extends PropertyType = PropertyType> = {
+    default?: SchemaDefaultValue<T>;
+    multiple?: boolean;
+    required?: boolean;
+    type: T;
+    uniq?: boolean;
+};
+export type Schema = Record<string, SchemaField>;
+type TypeMappingWrite = {
+    boolean: boolean;
+    datetime: DatetimeObject | string;
+    null: null;
+    number: number;
+    string: string;
+};
+export type OptionalKeysWrite<S extends Schema = Schema> = {
+    [Key in keyof S]: S[Key]['required'] extends false ? Key : S[Key]['default'] extends SchemaDefaultValue ? Key : never;
+}[keyof S];
+export type RequiredKeysWrite<S extends Schema = Schema> = {
+    [Key in keyof S]: S[Key]['required'] extends false ? never : S[Key]['default'] extends SchemaDefaultValue ? never : Key;
+}[keyof S];
+export type InferSchemaTypesWrite<S extends Schema = Schema> = FlattenTypes<{
+    [Key in RequiredKeysWrite<S>]: S[Key]['multiple'] extends true ? TypeMappingWrite[S[Key]['type']][] : TypeMappingWrite[S[Key]['type']];
+} & {
+    [Key in OptionalKeysWrite<S>]?: S[Key]['multiple'] extends true ? TypeMappingWrite[S[Key]['type']][] : TypeMappingWrite[S[Key]['type']];
+}>;
+type TypeMappingRead = {
+    boolean: boolean;
+    datetime: string;
+    null: null;
+    number: number;
+    string: string;
+};
+export type OptionalKeysRead<S extends Schema = Schema> = {
+    [Key in keyof S]: S[Key]['required'] extends false ? Key : never;
+}[keyof S];
+export type RequiredKeysRead<S extends Schema = Schema> = {
+    [Key in keyof S]: S[Key]['required'] extends false ? never : Key;
+}[keyof S];
+export type InferSchemaTypesRead<S extends Schema = Schema> = FlattenTypes<{
+    [Key in RequiredKeysRead<S>]: S[Key]['multiple'] extends true ? TypeMappingRead[S[Key]['type']][] : TypeMappingRead[S[Key]['type']];
+} & {
+    [Key in OptionalKeysRead<S>]?: S[Key]['multiple'] extends true ? TypeMappingRead[S[Key]['type']][] : TypeMappingRead[S[Key]['type']];
+}>;
+export {};

package/types/types/utils.d.ts

@@ -0,0 +1,9 @@
+export type MaybePromise<T = any> = () => Promise<T> | T;
+export type RequireAtLeastOne<T> = {
+    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<keyof T, K>>>;
+}[keyof T];
+export type MaybeArray<T> = Array<T> | T;
+export type FlattenTypes<T> = T extends object ? {
+    [K in keyof T]: FlattenTypes<T[K]>;
+} : T;
+export type AnyObject = Record<string, any>;

package/types/types/value.d.ts

@@ -0,0 +1,35 @@
+import type { PROPERTY_TYPE_BOOLEAN, PROPERTY_TYPE_DATETIME, PROPERTY_TYPE_NULL, PROPERTY_TYPE_NUMBER, PROPERTY_TYPE_STRING } from '../common/constants.js';
+import type { MaybeArray } from './utils.js';
+export type DatetimeObject = {
+    $day?: number;
+    $hour?: number;
+    $microsecond?: number;
+    $millisecond?: number;
+    $minute?: number;
+    $month?: number;
+    $nanosecond?: number;
+    $second?: number;
+    $year: number;
+};
+export type DatetimeValue = DatetimeObject | string;
+export type BooleanValue = boolean;
+export type NullValue = null;
+export type NumberValue = number;
+export type StringValue = string;
+export type PropertyType = typeof PROPERTY_TYPE_BOOLEAN | typeof PROPERTY_TYPE_DATETIME | typeof PROPERTY_TYPE_NULL | typeof PROPERTY_TYPE_NUMBER | typeof PROPERTY_TYPE_STRING;
+export type Property = {
+    id: string;
+    metadata?: string;
+    name: string;
+    type: PropertyType;
+};
+export type PropertyWithValue = Property & {
+    value: PropertyValue;
+};
+export type PropertyValuesData = {
+    max?: number;
+    min?: number;
+    values: PropertyValue[];
+};
+export type PropertySingleValue<TType extends PropertyType = PropertyType> = TType extends typeof PROPERTY_TYPE_DATETIME ? DatetimeValue : TType extends typeof PROPERTY_TYPE_NUMBER ? NumberValue : TType extends typeof PROPERTY_TYPE_STRING ? StringValue : TType extends typeof PROPERTY_TYPE_NULL ? NullValue : TType extends typeof PROPERTY_TYPE_BOOLEAN ? BooleanValue : StringValue;
+export type PropertyValue<TType extends PropertyType = PropertyType> = MaybeArray<PropertySingleValue<TType>>;