rads-db 3.0.83 → 3.1.0

package/dist/types-7e792d1f.d.ts

@@ -0,0 +1,449 @@
+import { EntityMeta, 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'>>;
+}
+
+interface RadsConfig {
+    dataSources: Record<string, RadsConfigDataSource>;
+}
+interface RadsConfigDataSource {
+    schema: () => MaybePromise<SchemaLoadResult>;
+}
+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>;
+interface SchemaLoadResult {
+    schema: Schema;
+    entitiesDir?: string;
+}
+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>;
+}
+type RadsDbInstance = RadsDb[keyof RadsDb];
+interface GetRestRoutesOptions {
+    /** Instance of RadsDb */
+    db: RadsDb[keyof 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: RadsDbInstance;
+    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>;
+}
+
+export { GetAggArgsAgg as $, GenerateClientOptions as A, GenerateClientNormalizedOptions as B, ComputedDecoratorArgs as C, DriverConstructor as D, EntityDecoratorArgs as E, FieldDecoratorArgs as F, GetRestRoutesOptions as G, RadsVitePluginOptions as H, FileSystemNode as I, RadsUiSlotName as J, RadsUiSlotDefinition as K, RadsFeature as L, MinimalDriver as M, Change as N, GetManyArgs as O, PutEffect as P, VerifyManyArgs as Q, RadsRequestContext as R, Schema as S, TypeDefinition as T, UiDecoratorArgs as U, ValidateEntityDecoratorArgs as V, WhereJsonContains as W, VerifyManyResponse as X, Where as Y, GetArgs as Z, GetAggArgs as _, UiFieldDecoratorArgs as a, GetManyArgsAny as a0, GetArgsAny as a1, GetAggArgsAny as a2, VerifyManyArgsAny as a3, GetArgsInclude as a4, GetAggResponse as a5, GetManyResponse as a6, GetResponse as a7, Get as a8, GetResponseInclude as a9, GetResponseIncludeSelect as aa, GetResponseNoInclude as ab, DeepPartialWithNulls as ac, DeepPartialWithNullsItem as ad, DeepPartial as ae, Relation as af, InverseRelation as ag, PutArgs as ah, Put as ai, DeepKeys as aj, EntityMethods as ak, ValidateFieldDecoratorArgs as b, Driver as c, ComputedContext as d, CreateRadsDbArgs as e, CreateRadsDbClientArgs as f, RadsConfig as g, RadsConfigDataSource as h, RequiredFields as i, ValidateStringDecoratorArgs as j, CreateRadsArgsDrivers as k, RestDriverOptions as l, CreateRadsDbArgsNormalized as m, SchemaLoadResult as n, SchemaValidators as o, FileUploadResult as p, FileUploadDriver as q, RadsDbInstance as r, GetRestRoutesArgs as s, GetRestRoutesResponse as t, FileUploadArgs as u, FieldDefinition as v, EnumDefinition as w, ComputedContextGlobal as x, RadsHookDoc as y, RestFileUploadDriverOptions as z };

package/integrations/cli.cjs

@@ -1,20 +1,5 @@
 #!/usr/bin/env node
 "use strict";
 
-var _nodeUtil = require("node:util");
 var _node = require("./node.cjs");
-const args = (0, _nodeUtil.parseArgs)({
-  options: {
-    entitiesDir: {
-      type: "string",
-      short: "d"
-    },
-    apiUrl: {
-      type: "string",
-      short: "u"
-    }
-  },
-  allowPositionals: false,
-  strict: true
-});
-(0, _node.generateClient)(args.values);
+(0, _node.generateClient)();

package/integrations/cli.mjs

@@ -1,18 +1,3 @@
 #!/usr/bin/env node
-import { parseArgs } from "node:util";
 import { generateClient } from "./node.mjs";
-const args = parseArgs({
-  options: {
-    entitiesDir: {
-      type: "string",
-      short: "d"
-    },
-    apiUrl: {
-      type: "string",
-      short: "u"
-    }
-  },
-  allowPositionals: false,
-  strict: true
-});
-generateClient(args.values);
+generateClient();

package/integrations/node.cjs

@@ -5,18 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.generateClient = generateClient;
 exports.getEntityTypesStrFromSchema = getEntityTypesStrFromSchema;
-exports.getIndexDts = getIndexDts;
-exports.getSchema = getSchema;
+exports.getIndexDtsInner = getIndexDtsInner;
+exports.getSchemas = getSchemas;
 var _promises = _interopRequireDefault(require("node:fs/promises"));
 var _nodeFs = _interopRequireDefault(require("node:fs"));
 var _nodePath = _interopRequireDefault(require("node:path"));
 var _lodash = _interopRequireDefault(require("lodash"));
-var _lib = require("./lib.cjs");
+var _jiti = require("jiti");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-async function generateClient(options) {
-  const normalizedOptions = normalizeOptions(options);
-  console.time("[rads-db] Schema generated in");
-  const schema = await getSchema(normalizedOptions);
+async function generateClient() {
+  console.time('"node_modules/_rads-db" generated in');
+  const config = await loadConfig();
+  const schemas = await getSchemas(config);
   const nodeModulesPath = _nodePath.default.resolve("./node_modules");
   const radsDbPath = _nodePath.default.join(nodeModulesPath, "./_rads-db");
   if (!_nodeFs.default.existsSync(nodeModulesPath)) {
@@ -25,14 +25,15 @@ async function generateClient(options) {
   if (!_nodeFs.default.existsSync(radsDbPath)) {
     await _promises.default.mkdir(radsDbPath);
   }
+  const schemasOnly = _lodash.default.mapValues(schemas, x => x.schema);
   const indexJsText = `
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema=${JSON.stringify(schema)}
+exports.schemas=${JSON.stringify(schemasOnly)}
 `.trim();
   const indexMjsText = `
-export const schema = ${JSON.stringify(schema)}
+export const schemas = ${JSON.stringify(schemasOnly)}
 `.trim();
-  const indexDtsText = getIndexDts(schema, normalizedOptions);
+  const indexDtsText = getIndexDts(schemas, config);
   await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./index.js"), indexJsText);
   await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./index.mjs"), indexMjsText);
   await _promises.default.writeFile(_nodePath.default.join(radsDbPath, "./index.d.ts"), indexDtsText);
@@ -43,71 +44,62 @@ export const schema = ${JSON.stringify(schema)}
     main: "./index.js",
     module: "./index.mjs",
     types: "./index.d.ts"
-    // browser: 'index-browser.js',
   }, null, 2));
-  console.timeEnd("[rads-db] Schema generated in");
+  console.timeEnd('"node_modules/_rads-db" generated in');
 }
-async function getSchema(normalizedOptions) {
-  const {
-    entitiesDir,
-    apiUrl
-  } = normalizedOptions;
-  let schema;
-  if (entitiesDir) {
-    if (!_nodeFs.default.existsSync(entitiesDir)) await _promises.default.mkdir(entitiesDir, {
-      recursive: true
-    });
-    const response = await _promises.default.readdir(entitiesDir, {
-      withFileTypes: true
-    });
-    const entities = {};
-    for (const file of response) {
-      if (!file.isFile()) continue;
-      if (!file.name.endsWith(".ts")) continue;
-      const text = await _promises.default.readFile(_nodePath.default.resolve(entitiesDir, file.name), "utf-8");
-      entities[file.name.slice(0, -3)] = text;
-    }
-    schema = (0, _lib.parseSchema)(entities);
-  } else if (apiUrl) {
-    const url = new URL("radsTunnel", apiUrl);
-    const fetchResponse = await fetch(url.href, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json"
-      },
-      body: JSON.stringify({
-        method: "_schema"
-      })
+async function loadConfig() {
+  const jiti = (0, _jiti.createJiti)(process.cwd());
+  const paths = ["./rads.config.ts", "./rads.config.js"];
+  let config;
+  for (const p of paths) {
+    config = await jiti.import(p, {
+      try: true
     });
-    schema = await fetchResponse.json();
-    if (!schema) {
-      throw new Error("Could not download schema from the server. Please check the server URL.");
+    if (config) break;
+  }
+  if (!config) {
+    throw new Error('File "./rads.config.ts" was not found. Please make sure it is present in the root of your project.');
+  }
+  return config;
+}
+async function getSchemas(config) {
+  const result = {};
+  for (const key in config.dataSources) {
+    if (!config.dataSources[key].schema) {
+      throw new Error(`Data source "${key}" does not have a schema. Please, specify it in rads.config.ts`);
     }
-  } else {
-    throw new Error("Please specify entitiesDir or apiUrl");
+    result[key] = await config.dataSources[key].schema();
+  }
+  return result;
+}
+function getIndexDts(schemas, config) {
+  const parts = [];
+  const rootTypeFields = [];
+  for (const key in schemas) {
+    let rootTypeName = _lodash.default.camelCase(key);
+    rootTypeName = rootTypeName[0].toUpperCase() + rootTypeName.slice(1);
+    const indexDtsStr = getIndexDtsInner(schemas[key].schema, rootTypeName, schemas[key].entitiesDir);
+    rootTypeFields.push(`${key}: ${rootTypeName}`);
+    parts.push(indexDtsStr);
   }
-  return schema;
+  parts.push(`
+export interface RadsDb {
+  ${rootTypeFields.join("\n")}
 }
-function normalizeOptions(options) {
-  options = options || {};
-  if (options.entitiesDir && options.apiUrl) throw new Error('You cannot specify both "apiUrl" and "entitiesDir". Choose one.');
-  if (options.apiUrl) return options;
-  return {
-    entitiesDir: "./entities",
-    ...options
-  };
+    `.trim());
+  return parts.join("\n\n");
 }
-function getIndexDts(schema, options) {
+function getIndexDtsInner(schema, rootTypeName, entitiesDir) {
   const imports = [];
   const rootFields = [];
   const whereTypes = [];
   const entityMeta = [];
-  const schemaTypesStr = options.entitiesDir ? "" : getEntityTypesStrFromSchema(schema);
+  const schemaTypesStr = entitiesDir ? "" : getEntityTypesStrFromSchema(schema);
   for (const key in schema) {
     const type = schema[key];
     if (!type.fields) continue;
-    if (options.entitiesDir && type.sourceFile) {
-      imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${type.sourceFile}'`);
+    if (entitiesDir && type.sourceFile) {
+      imports.push(`import type { ${type.name} } from '../../${entitiesDir}/${type.sourceFile}'`);
     }
     if (type.decorators?.entity) {
       rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}'>`);
@@ -161,7 +153,7 @@ interface Reference_Where {
 
 ${whereTypes.join("\n\n")}
 
-export interface RadsDb {
+export interface ${rootTypeName} {
   _schema: any
   uploadFile: (args: FileUploadArgs, ctx?: RadsRequestContext) => Promise<{ url: string }>
   ${rootFields.join("\n")}

package/integrations/node.d.ts

@@ -1,5 +1,6 @@
-import type { GenerateClientNormalizedOptions, GenerateClientOptions, Schema } from '@/types';
-export declare function generateClient(options?: GenerateClientOptions): Promise<void>;
-export declare function getSchema(normalizedOptions: GenerateClientNormalizedOptions): Promise<any>;
-export declare function getIndexDts(schema: Schema, options: GenerateClientNormalizedOptions): string;
+import type { RadsConfig, Schema } from '@/types';
+/** Functions in this file are used by CLI and all other integrations */
+export declare function generateClient(): Promise<void>;
+export declare function getSchemas(config: RadsConfig): Promise<Record<string, SchemaLoadResult>>;
+export declare function getIndexDtsInner(schema: Schema, rootTypeName: string, entitiesDir?: string): string;
 export declare function getEntityTypesStrFromSchema(schema: Schema): string;