rads-db 3.0.84 → 3.1.2

package/{integrations/lib.mjs → dist/config.mjs}

@@ -1,7 +1,10 @@
-import { ScriptTarget, SyntaxKind, createSourceFile } from "typescript";
-import _ from "lodash";
+import fs from 'node:fs';
+import path from 'node:path';
+import { SyntaxKind, createSourceFile, ScriptTarget } from 'typescript';
+import _ from 'lodash';
+
 const supportedPrimitiveTypes = ["string", "number", "boolean", "Record<string, string>", "Record<string, any>"];
-export function parseSchema(typescriptFiles) {
+function parseSchema(typescriptFiles) {
   const typeNodesMap = getTypeNodesMap(typescriptFiles);
   const schema = getSchema(typeNodesMap);
   resolveIsExtending(schema);
@@ -582,3 +585,43 @@ function verifyRelationFields(result) {
     }
   }
 }
+
+function defineRadsConfig(config) {
+  return config;
+}
+function schemaFromFiles(entitiesDir) {
+  return async () => {
+    if (!fs.existsSync(entitiesDir))
+      await fs.promises.mkdir(entitiesDir, { recursive: true });
+    const response = await fs.promises.readdir(entitiesDir, { withFileTypes: true });
+    const entities = {};
+    for (const file of response) {
+      if (!file.isFile())
+        continue;
+      if (!file.name.endsWith(".ts"))
+        continue;
+      const text = await fs.promises.readFile(path.resolve(entitiesDir, file.name), "utf-8");
+      entities[file.name.slice(0, -3)] = text;
+    }
+    return { schema: parseSchema(entities), entitiesDir };
+  };
+}
+function schemaFromRadsApi(radsApiUrl) {
+  return async () => {
+    if (!radsApiUrl.endsWith("/"))
+      radsApiUrl += "/";
+    const url = new URL("radsTunnel", radsApiUrl);
+    const fetchResponse = await fetch(url.href, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ method: "_schema" })
+    });
+    const schema = await fetchResponse.json();
+    if (!schema) {
+      throw new Error("Could not download schema from the server. Please check the server URL.");
+    }
+    return { schema };
+  };
+}
+
+export { defineRadsConfig, schemaFromFiles, schemaFromRadsApi };

package/dist/index.cjs

@@ -1273,13 +1273,13 @@ function keepHistory() {
   };
 }
 
-function createRadsDb(args) {
+function createRadsDb(dataSourceKey, args) {
   args = { ...args };
-  const s = args.schema || _radsDb.schema;
+  const s = args.schema || _radsDb.schemas[dataSourceKey];
   const validators = generateValidators(s);
   return generateMethods(s, validators, args);
 }
-function createRadsDbClient(args) {
+function createRadsDbClient(dataSourceKey, args) {
   const radsDbArgs = {
     ...args,
     noComputed: true,
@@ -1287,7 +1287,7 @@ function createRadsDbClient(args) {
     keepNulls: true,
     driver: restApi(args?.driver)
   };
-  const s = radsDbArgs.schema || _radsDb.schema;
+  const s = radsDbArgs.schema || _radsDb.schemas[dataSourceKey];
   const validators = generateValidators(s);
   return generateMethods(s, validators, radsDbArgs);
 }

package/dist/index.d.ts

@@ -1,441 +1,8 @@
-import { EntityMeta, RadsDb } from '_rads-db';
+import { E as EntityDecoratorArgs, U as UiDecoratorArgs, a as UiFieldDecoratorArgs, V as ValidateEntityDecoratorArgs, b as ValidateFieldDecoratorArgs, F as FieldDecoratorArgs, C as ComputedDecoratorArgs, S as Schema, D as DriverConstructor, c as Driver, d as ComputedContext, R as RadsRequestContext, e as CreateRadsDbArgs, f as CreateRadsDbClientArgs } from './types-7e792d1f.js';
+export { N as Change, x as ComputedContextGlobal, k as CreateRadsArgsDrivers, m as CreateRadsDbArgsNormalized, aj as DeepKeys, ae as DeepPartial, ac as DeepPartialWithNulls, ad as DeepPartialWithNullsItem, ak as EntityMethods, w as EnumDefinition, v as FieldDefinition, I as FileSystemNode, u as FileUploadArgs, q as FileUploadDriver, p as FileUploadResult, B as GenerateClientNormalizedOptions, A as GenerateClientOptions, a8 as Get, _ as GetAggArgs, $ as GetAggArgsAgg, a2 as GetAggArgsAny, a5 as GetAggResponse, Z as GetArgs, a1 as GetArgsAny, a4 as GetArgsInclude, O as GetManyArgs, a0 as GetManyArgsAny, a6 as GetManyResponse, a7 as GetResponse, a9 as GetResponseInclude, aa as GetResponseIncludeSelect, ab as GetResponseNoInclude, s as GetRestRoutesArgs, G as GetRestRoutesOptions, t as GetRestRoutesResponse, ag as InverseRelation, M as MinimalDriver, ai as Put, ah as PutArgs, P as PutEffect, g as RadsConfig, h as RadsConfigDataSource, r as RadsDbInstance, L as RadsFeature, y as RadsHookDoc, K as RadsUiSlotDefinition, J as RadsUiSlotName, H as RadsVitePluginOptions, af as Relation, i as RequiredFields, l as RestDriverOptions, z as RestFileUploadDriverOptions, n as SchemaLoadResult, o as SchemaValidators, T as TypeDefinition, j as ValidateStringDecoratorArgs, Q as VerifyManyArgs, a3 as VerifyManyArgsAny, X as VerifyManyResponse, Y as Where, W as WhereJsonContains } from './types-7e792d1f.js';
+import { RadsDb } from '_rads-db';
 export { RadsDb } from '_rads-db';
 
-type MaybePromise$1<T> = Promise<T> | T;
-type Change<T> = {
-    [K in keyof T]?: T[K] extends any[] ? T[K] : T[K] extends {} ? Change<T[K]> : T[K];
-};
-interface GetManyArgs<EN extends keyof EntityMeta> extends GetArgs<EN> {
-    cursor?: string | null;
-    maxItemCount?: number;
-    orderBy?: string;
-}
-interface VerifyManyArgs<EN extends keyof EntityMeta> extends GetManyArgs<EN> {
-    recompute?: string[];
-    dryRun?: boolean;
-}
-interface VerifyManyResponse {
-    cursor: string | null;
-    correctCount: number;
-    incorrectCount: number;
-    incorrectDocs: {
-        id: string;
-        diff: any;
-        toRemove?: any;
-    }[];
-}
-type Where<EN extends keyof EntityMeta> = EntityMeta[EN]['whereType'] & {
-    _not?: Where<EN>;
-    _and?: Where<EN>[];
-    _or?: Where<EN>[];
-};
-interface GetArgs<EN extends keyof EntityMeta> {
-    where?: Where<EN>;
-    include?: GetArgsInclude<EN>;
-}
-interface GetAggArgs<EN extends keyof EntityMeta> {
-    where?: Where<EN>;
-    agg: GetAggArgsAgg<EN>;
-}
-type GetAggArgsAgg<EN extends keyof EntityMeta, F extends string = EntityMeta[EN]['aggregates']> = ('_count' | `${F}_min` | `${F}_max` | `${F}_sum`)[];
-type GetManyArgsAny = GetManyArgs<any>;
-type GetArgsAny = GetArgs<any>;
-type GetAggArgsAny = GetAggArgs<any>;
-type VerifyManyArgsAny = VerifyManyArgs<any>;
-type RelationsAndNestedObjects<EN extends keyof EntityMeta> = EntityMeta[EN]['relations'] & EntityMeta[EN]['nestedObjects'];
-type GetArgsInclude<EN extends keyof EntityMeta, R extends keyof RelationsAndNestedObjects<EN> = keyof RelationsAndNestedObjects<EN>> = [R] extends [never] ? {
-    _pick?: EntityMeta[EN]['primitives'][];
-} : {
-    _pick?: EntityMeta[EN]['primitives'][];
-} & {
-    [K in R]?: GetArgsInclude<RelationsAndNestedObjects<EN>[K]['entityName']>;
-};
-type GetAggResponse<EN extends keyof EntityMeta, A extends GetAggArgs<EN>> = {
-    [K in A['agg'][0]]: K extends '_count' ? number : number | undefined;
-};
-interface GetManyResponse<EN extends keyof EntityMeta, A extends GetArgs<EN>> {
-    nodes: GetResponse<EN, A>[];
-    cursor: string | null;
-}
-type GetResponse<EN extends keyof EntityMeta, A extends GetArgs<EN>> = A extends {
-    include: any;
-} ? GetResponseInclude<EN, A['include']> : GetResponseNoInclude<EN>;
-type Get<EntityName extends keyof EntityMeta, Include extends keyof EntityMeta[EntityName]['relations'] | GetArgsInclude<EntityName> = {}> = [Include] extends [Record<string, any>] ? GetResponse<EntityName, {
-    include: Include;
-}> : GetResponse<EntityName, {
-    include: {
-        [K in Include]: {};
-    };
-}>;
-type RelationData<EN extends keyof EntityMeta, K extends keyof EntityMeta[EN]['relations']> = Pick<EntityMeta[EN]['relations'][K]['entity'], EntityMeta[EN]['relations'][K]['denormFields']>;
-type KeepArray<TMaybeArray, TType> = NonNullable<TMaybeArray> extends any[] ? TType[] : TType;
-type GetResponseInclude<EN extends keyof EntityMeta, I extends GetArgsInclude<EN>> = I extends {
-    _pick: string[];
-} ? GetResponseIncludeSelect<EN, I> : {
-    [K in keyof EntityMeta[EN]['type']]: K extends keyof EntityMeta[EN]['relations'] ? K extends keyof I ? KeepArray<EntityMeta[EN]['type'][K], GetResponseInclude<EntityMeta[EN]['relations'][K]['entityName'], I[K]>> : KeepArray<EntityMeta[EN]['type'][K], RelationData<EN, K>> : EntityMeta[EN]['type'][K];
-};
-interface GetResponseIncludeSelect<EN extends keyof EntityMeta, I> {
-}
-type GetResponseNoInclude<EN extends keyof EntityMeta> = {
-    [K in keyof EntityMeta[EN]['type']]: K extends keyof EntityMeta[EN]['relations'] ? KeepArray<EntityMeta[EN]['type'][K], RelationData<EN, K>> : EntityMeta[EN]['type'][K];
-};
-type DeepPartialWithNulls<T> = {
-    [K in keyof T]?: NonNullable<T[K]> extends any[] ? DeepPartialWithNullsItem<NonNullable<T[K]>[number]>[] : DeepPartialWithNullsItem<NonNullable<T[K]>>;
-};
-type DeepPartialWithNullsItem<T> = T extends {
-    id: string;
-} ? {
-    id: string;
-} | null : T extends Record<string, any> ? DeepPartialWithNulls<T> | null : T | null;
-type DeepPartial<T> = {
-    [K in keyof T]?: NonNullable<T[K]> extends any[] ? DeepPartial<NonNullable<T[K]>[number]>[] : NonNullable<T[K]> extends Record<string, any> ? DeepPartial<T[K]> : T[K];
-};
-/** Indicates that this field is a relation to another entity in the database.
- * Only id will be stored in the database.
- * If you want to store additional fields, please, pass them as the second type argument */
-type Relation<T extends {
-    id: any;
-}, K extends Exclude<keyof T, 'id'> = never> = Pick<T, K | 'id'>;
-/** Indicates that this is computed field - all documents that point to this document via Relation<>.
- * Note: this field is not stored in the database at all. Returns up to 100 items and doesn't support pagination
- * If you need more control, please, use separate request instead.
- */
-type InverseRelation<EN extends keyof EntityMeta, _Field extends keyof EntityMeta[EN]['relations']> = EntityMeta[EN]['type'];
-type PutArgs<T> = {
-    id: string;
-} & DeepPartialWithNulls<T>;
-type Put<EntityName extends keyof EntityMeta> = PutArgs<EntityMeta[EntityName]['type']>;
-type DeepKeys<T> = T extends object ? {
-    [K in (string | number) & keyof T]: `${`.${K}` | (`${K}` extends `${number}` ? `[${K}]` : never)}${'' | DeepKeys<T[K]>}`;
-}[(string | number) & keyof T] : never;
-interface EntityMethods<E, EN extends keyof EntityMeta> {
-    /** Returns object with with random UUID as `id` and prefilled default values */
-    construct(defaultValues?: DeepPartial<E>): E;
-    /** Used to access underlying mechanism of storage directly.
-     * Warning: bypasses all rads features - schema won't be validated, default values won't be filled, etc. */
-    driver: Driver;
-    get<A extends GetArgs<EN>>(args: A, ctx?: RadsRequestContext): MaybePromise$1<GetResponse<EN, A>>;
-    getMany<A extends GetManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<GetManyResponse<EN, A>>;
-    getAgg<A extends GetAggArgs<EN>>(args: A, ctx?: RadsRequestContext): MaybePromise$1<GetAggResponse<EN, A>>;
-    getAll<A extends GetManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<GetManyResponse<EN, A>['nodes']>;
-    put(data: PutArgs<E>, ctx?: RadsRequestContext): MaybePromise$1<GetResponseNoInclude<EN>>;
-    putMany(data: PutArgs<E>[], ctx?: RadsRequestContext): MaybePromise$1<GetResponseNoInclude<EN>[]>;
-    verifyMany<A extends VerifyManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<VerifyManyResponse>;
-    verifyAll<A extends VerifyManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<Pick<VerifyManyResponse, 'correctCount' | 'incorrectCount'>>;
-}
-
-type MaybePromise<T> = Promise<T> | T;
-type RequiredFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
-type ValidateFieldDecoratorArgs<T> = T extends string ? ValidateStringDecoratorArgs : T extends number ? ValidateNumberDecoratorArgs : ValidateAnyDecoratorArgs;
-interface ValidateEntityDecoratorArgs {
-}
-interface ValidateAnyDecoratorArgs {
-}
-interface ValidateNumberDecoratorArgs {
-    isWhole?: boolean;
-    min?: number;
-    max?: number;
-}
-interface ValidateStringDecoratorArgs {
-    preset?: 'text' | 'html' | 'markdown' | 'alpha' | 'alphanum' | 'number' | 'decimalNumber' | 'email' | 'icon' | 'imageUrl' | 'fileUrl' | 'absoluteUrl' | 'relativeUrl' | 'phoneNumber' | 'datetime' | 'date' | 'time' | 'timeInterval' | 'duration';
-    regex?: RegExp | string;
-    minLength?: number;
-    maxLength?: number;
-}
-interface UiFieldDecoratorArgs {
-    /** User-friendly name of the entity (singular).
-     * Used as editor field label and column name in exports.
-     * Defaults to `_.startCase(fieldName)` */
-    name?: string;
-    /** Icon to display as editor field icon. E.g. `mdi-user`. */
-    icon?: string;
-    /** Free text - hint to display under editor field in UI */
-    hint?: string;
-    /** If true, field is hidden from the rads-ui */
-    isHidden?: boolean;
-    /** If true, field is readonly in the rads-ui */
-    isReadonly?: boolean;
-    /** If true, field can be edited only during creation */
-    isImmutable?: boolean;
-    /** TODO: Preferred component to display or edit this value */
-    component?: string;
-}
-interface UiDecoratorArgs<T = any> {
-    /** User-friendly name of the entity (singular).
-     * Defaults to `_.startCase(entityName).split(' ').slice(1).join(' ')` (i.e. removes the prefix) */
-    name?: string;
-    /** User-friendly name of the entity (plural)
-     * Defaults to `pluralize(entityName)` */
-    namePlural?: string;
-    /** Icon to display near this entity. Defaults to `mdi-file-outline` */
-    icon?: string;
-    /** Field that contains "name" value.
-     * Used by Rads UI to set up default search and display behaviour
-     * Defaults to (if field with such name exists) `name` > `title` > `id` */
-    nameField?: keyof T;
-    /** Some important-to-know fields, like "id" or "code" or "description".
-     * Used by Rads UI to display in the list view
-     * Defaults to `["id"]` */
-    captionFields?: (keyof T)[];
-    /** Field that contains value that points to either:
-     * - icon (e.g. 'mdi-test')
-     * - image URL (e.g. 'https://radsjs.com/icon.png'). Make sure it's not too big (around 200x200px)
-     * Used by Rads UI to display it in the list view.
-     * Defaults to (if exists) `image` > `photo` > `thumbnail` > `icon` > undefined */
-    iconField?: keyof T;
-    /** Search operator that's used in simple search by name. Defaults to 'istartsWith' */
-    searchOperator?: 'startsWith' | 'istartsWith' | 'contains' | 'icontains';
-    /** Defines section name in rads-ui where this entity will be grouped under */
-    group?: string;
-    /** If true, field is hidden from the rads-ui */
-    isHidden?: boolean;
-}
-interface EntityDecoratorArgs {
-    driver?: string;
-}
-interface ComputedDecoratorArgs {
-    preset: string;
-}
-interface FieldDecoratorArgs {
-    relation?: Function;
-}
-type DriverConstructor = (schema: Schema, entity: string) => MinimalDriver;
-interface CreateRadsArgsDrivers {
-    default: DriverConstructor;
-    [driverName: string]: DriverConstructor;
-}
-interface RestDriverOptions {
-    /** @default '/api' */
-    baseUrl?: string;
-    fetch?: (url: string, options?: {
-        body?: any;
-        headers?: any;
-        method?: string;
-    }) => any;
-    getHeaders?: (radsDbRequest: {
-        args?: any;
-        context?: RadsRequestContext;
-    }) => Record<string, string> | undefined;
-}
-interface CreateRadsDbArgs {
-    schema?: Schema;
-    driver?: DriverConstructor | CreateRadsArgsDrivers;
-    fileUploadDriver?: FileUploadDriver;
-    noComputed?: boolean;
-    noCustomDrivers?: boolean;
-    computed?: Record<string, Record<string, Function> | {
-        _entity?: {
-            compute: Function;
-            recomputeWhen: Record<string, (args: any) => boolean>;
-        };
-    }>;
-    beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<void>;
-    context?: Record<string, any> & Omit<RadsRequestContext, 'dryRun' | 'silent'>;
-    features?: RadsFeature[];
-    keepNulls?: boolean;
-}
-type CreateRadsDbArgsNormalized = RequiredFields<CreateRadsDbArgs, 'computed' | 'features'> & {
-    driver: CreateRadsArgsDrivers;
-};
-type CreateRadsDbClientArgs = Omit<CreateRadsDbArgs, 'noComputed' | 'noCustomDrivers' | 'driver'> & {
-    driver?: RestDriverOptions;
-};
-type Schema = Record<string, TypeDefinition>;
-type SchemaValidators = Record<string, (item: any) => any>;
-interface TypeDefinition {
-    name: string;
-    decorators: Record<string, Record<string, any>>;
-    comment?: string;
-    precomputedFields?: string[];
-    computedFields?: string[];
-    nestedTypeFields?: string[];
-    fields?: Record<string, FieldDefinition>;
-    enumValues?: Record<string, EnumDefinition>;
-    handle?: string;
-    handlePlural?: string;
-    isExtending?: string;
-    keepHistoryFields?: string[];
-    sourceFile?: string;
-}
-interface FileUploadResult {
-    url: string;
-}
-interface FileUploadDriver {
-    driverName: string;
-    client?: any;
-    uploadFile(args: FileUploadArgs, ctx?: RadsRequestContext): Promise<FileUploadResult>;
-}
-interface GetRestRoutesOptions {
-    /** Instance of RadsDb */
-    db: RadsDb;
-    /** Prefix to use for generated routes. Defaults to "/api/" */
-    prefix?: string;
-    /** By default, rest endpoints for manipulating local files are exposed when NODE_ENV === 'development'. Set to true or false to override. */
-    exposeFilesystem?: boolean;
-}
-interface GetRestRoutesArgs {
-    body?: any;
-    context: any;
-    headers: Record<string, string | undefined>;
-}
-type GetRestRoutesResponse = Record<string, Partial<Record<string, (args: GetRestRoutesArgs, ctx?: RadsRequestContext) => Promise<any>>>>;
-interface FileUploadArgs {
-    blob: Blob;
-    fileName: string;
-    containerName?: string;
-    options?: any;
-}
-interface MinimalDriver {
-    driverName: string;
-    /** raw underlying data access service - e.g. sql client or azure storage client */
-    client?: any;
-    putMany: (item: Record<string, any>[], ctx?: RadsRequestContext) => MaybePromise<void>;
-    getMany: (args?: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<{
-        nodes: Record<string, any>[];
-        cursor: string | null;
-    }>;
-    get?: (args: GetArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any> | null>;
-    getAll?: (args: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any>[]>;
-    getAgg?: (args: GetAggArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any>>;
-    deleteMany?: (args: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<{
-        nodes: Record<string, any>[];
-        cursor: string | null;
-    }>;
-    deleteAll?: (args: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any>[]>;
-    put?: (data: Record<string, any>, ctx?: RadsRequestContext) => MaybePromise<void>;
-    verifyMany?: (args?: VerifyManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<VerifyManyResponse>;
-}
-type Driver = Required<Omit<MinimalDriver, 'verifyMany' | 'client'>> & Pick<MinimalDriver, 'verifyMany' | 'client'>;
-interface FieldDefinition {
-    name: string;
-    type: string;
-    defaultValue?: any;
-    defaultValueClass?: string;
-    defaultValueCopyFrom?: string;
-    isRequired?: boolean;
-    isArray?: boolean;
-    isRelation?: boolean;
-    isInverseRelation?: boolean;
-    isChange?: boolean;
-    inverseRelationField?: string;
-    relationDenormFields?: string[];
-    comment?: string;
-    decorators?: Record<string, Record<string, any>>;
-}
-interface EnumDefinition {
-    name: string;
-    comment?: string;
-    decorators?: Record<string, Record<string, any>>;
-}
-interface ComputedContextGlobal {
-    db: RadsDb;
-    schema: Schema;
-    validators: SchemaValidators;
-    options: CreateRadsDbArgs;
-    drivers: Record<string, Driver>;
-    effects: Record<string, PutEffect[]>;
-}
-interface ComputedContext extends ComputedContextGlobal {
-    typeName: string;
-    handle: string;
-}
-interface RadsHookDoc {
-    /** Updated document that will be saved to the database */
-    doc: any;
-    /** Previous version of document - i.e. one that is currently in the database (before saving) */
-    oldDoc: any;
-    /** If current entity is event sourcing aggregate, you can access all events in the chronological order */
-    events?: any;
-}
-interface PutEffect {
-    beforePut?: (computedContext: ComputedContext, docs: RadsHookDoc[], ctx: RadsRequestContext) => MaybePromise<any>;
-    afterPut: (computedContext: ComputedContext, docs: RadsHookDoc[], beforePutResult: any, ctx: RadsRequestContext) => MaybePromise<any>;
-}
-interface RestFileUploadDriverOptions {
-    /** @default '/api' */
-    baseUrl?: string;
-    fetch?: (url: string, options?: {
-        body?: any;
-        headers?: any;
-        method?: string;
-    }) => any;
-    /** If true, "multipart/form-data" body will be used (sometimes causes problems in serverless environments).
-     * Otherwise, "application/json" body (with base64-encoded binary content) will be used */
-    useFormData?: boolean;
-}
-type GenerateClientOptions = GenerateClientNormalizedOptions;
-interface GenerateClientNormalizedOptions {
-    /** For servers - path to your entities directory, e.g. "./entities" */
-    entitiesDir?: string;
-    /** For client-only integrations - base url of your API, e.g. "https://my-website/api" */
-    apiUrl?: string;
-}
-interface RadsVitePluginOptions extends GenerateClientOptions {
-    /** To simplify debugging, makes modules available on window.
-     * For example, "/src/stores/userStore.ts" will be available at window.stores.userStore.
-     * You can pass the regex - if filename satisfies it, it will be exposed.
-     * Path inside window is determined by first matching group in said regex.
-     * If `true`, default regex is used - `/\/src\/((services|stores)\/(.+))\.[tj]s$/`   */
-    exposeModulesInDev?: boolean | RegExp;
-}
-interface RadsRequestContext {
-    _logs?: any[];
-    log?: (requestInfo: any) => void;
-    getUser?: () => {
-        id: string;
-        role: string;
-    } | undefined;
-    /** If true, no changes made to the database - instead, all changes are returned as logs */
-    dryRun?: boolean;
-    /** (Not supported yet) If true, updatedAt/updatedBy properties are not updated, and log records are not created */
-    silent?: boolean;
-    /** Mostly for internal use. When entity name is specified, indicates that calling put* on this entity is allowed, even if it's marked as @precomputed or @readonly */
-    skipPrecomputedCheckFor?: string;
-    /** Method that was called - get, getAll, getMany, getAgg, put, putMany, etc */
-    method?: 'get' | 'getAll' | 'getMany' | 'getAgg' | 'put' | 'putMany' | 'deleteMany' | 'deleteAll';
-    /** if true, all cache layers will be bypassed */
-    noCache?: boolean;
-    [key: string]: any;
-}
-interface FileSystemNode {
-    path: string;
-    size?: number;
-    type: 'blob' | 'tree';
-}
-interface WhereJsonContains {
-    /** Checks for existence of this path inside json object
-     * Example: "meta.countries[0].name". */
-    path: string;
-    /** Checks if value from "path" is exactly null. Note: it is not the same as not having the key in the object. */
-    isNull?: boolean;
-    /** Checks if value from "path" equals provided value */
-    value?: number | string | boolean;
-}
-type RadsUiSlotName = 'entityListActions' | 'entityActions' | 'fieldActions';
-interface RadsUiSlotDefinition {
-    entityName?: string | {
-        regExp: string;
-    };
-    fieldName?: string | {
-        regExp: string;
-    };
-    label: string;
-    icon?: string;
-    endpoint: string;
-}
-interface RadsFeature {
-    name: string;
-    radsUiSlots?: Record<RadsUiSlotName, RadsUiSlotDefinition[]>;
-    init?: (db: Record<string, any>, context: ComputedContextGlobal) => void;
-    enhanceEntityMethods?: (context: ComputedContext, entityMethodsObj: EntityMethods<any, any>) => void;
-    beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<any>;
-    afterGet?: (items: any[], args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<void>;
-    beforePut?: (items: RadsHookDoc[], ctx: RadsRequestContext, computedContext: ComputedContext) => void;
-    afterPut?: (items: RadsHookDoc[], ctx: RadsRequestContext, computedContext: ComputedContext) => void;
-    beforeUploadFile?: (args: FileUploadArgs) => MaybePromise<any>;
-    afterUploadFile?: (result: FileUploadResult, args: FileUploadArgs) => MaybePromise<void>;
-}
-
 declare function entity<T>(meta?: EntityDecoratorArgs): (classConstructor: new () => T, _ctx?: ClassDecoratorContext<any>) => void;
 declare function ui<T>(args: T extends new () => any ? UiDecoratorArgs<InstanceType<T>> : UiFieldDecoratorArgs): (classConstructor: T, _ctx?: ClassDecoratorContext | ClassFieldDecoratorContext) => void;
 declare function validate<T, C, F>(args: T extends new () => any ? ValidateEntityDecoratorArgs : ValidateFieldDecoratorArgs<F>): (classConstructor: T, _ctx?: ClassDecoratorContext | ClassFieldDecoratorContext<C, F>) => void;
@@ -459,12 +26,12 @@ declare function cleanUndefinedAndNull(obj: Record<string, any>, isChange?: bool
  * Creates instance of rads db - object that provides access to all entities.
  * Intended to be used on the backend. On the client you may want to opt for "createRadsDbClient" instead.
  * */
-declare function createRadsDb(args?: CreateRadsDbArgs): RadsDb;
+declare function createRadsDb<T extends keyof RadsDb>(dataSourceKey: T, args?: CreateRadsDbArgs): RadsDb[T];
 /**
  * Creates instance of rads db client - object that provides access to all entities.
  * Intended to be used on the frontend. Uses "fetch" to communicate with the server's API.
- * It is a shortcut for `createRadsDb({ driver: radsRestApi(), noComputed: true, noCustomDrivers: true })`
+ * It is a shortcut for `createRadsDb('db', { driver: radsRestApi(), noComputed: true, noCustomDrivers: true })`
  */
-declare function createRadsDbClient(args?: CreateRadsDbClientArgs): RadsDb;
+declare function createRadsDbClient<T extends keyof RadsDb>(dataSourceKey: T, args?: CreateRadsDbClientArgs): RadsDb[T];
 
-export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgsDrivers, CreateRadsDbArgs, CreateRadsDbArgsNormalized, CreateRadsDbClientArgs, DeepKeys, DeepPartial, DeepPartialWithNulls, DeepPartialWithNullsItem, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, EnumDefinition, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, FileUploadResult, GenerateClientNormalizedOptions, GenerateClientOptions, Get, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, InverseRelation, MinimalDriver, Put, PutArgs, PutEffect, RadsFeature, RadsHookDoc, RadsRequestContext, RadsUiSlotDefinition, RadsUiSlotName, RadsVitePluginOptions, Relation, RequiredFields, RestDriverOptions, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, Where, WhereJsonContains, cleanUndefinedAndNull, computed, createRadsDb, createRadsDbClient, diff, entity, field, getDriverInstance, handlePrecomputed, keepHistory, merge, precomputed, ui, validate };
+export { ComputedContext, ComputedDecoratorArgs, CreateRadsDbArgs, CreateRadsDbClientArgs, Driver, DriverConstructor, EntityDecoratorArgs, FieldDecoratorArgs, RadsRequestContext, Schema, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, cleanUndefinedAndNull, computed, createRadsDb, createRadsDbClient, diff, entity, field, getDriverInstance, handlePrecomputed, keepHistory, merge, precomputed, ui, validate };

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { z, ZodNullable, ZodOptional, ZodLazy, ZodObject, ZodError } from 'zod';
 import _ from 'lodash';
 import { v4 } from 'uuid';
 import createMerge from '@fastify/deepmerge';
-import { schema } from '_rads-db';
+import { schemas } from '_rads-db';
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -1266,13 +1266,13 @@ function keepHistory() {
   };
 }
 
-function createRadsDb(args) {
+function createRadsDb(dataSourceKey, args) {
   args = { ...args };
-  const s = args.schema || schema;
+  const s = args.schema || schemas[dataSourceKey];
   const validators = generateValidators(s);
   return generateMethods(s, validators, args);
 }
-function createRadsDbClient(args) {
+function createRadsDbClient(dataSourceKey, args) {
   const radsDbArgs = {
     ...args,
     noComputed: true,
@@ -1280,7 +1280,7 @@ function createRadsDbClient(args) {
     keepNulls: true,
     driver: restApi(args?.driver)
   };
-  const s = radsDbArgs.schema || schema;
+  const s = radsDbArgs.schema || schemas[dataSourceKey];
   const validators = generateValidators(s);
   return generateMethods(s, validators, radsDbArgs);
 }