rads-db 0.1.111 → 3.0.0

package/dist/index.cjs

@@ -5,11 +5,13 @@ const _ = require('lodash');
 const uuid = require('uuid');
 const createMerge = require('@fastify/deepmerge');
 const _radsDb = require('_rads-db');
+const pluralize = require('pluralize');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const ___default = /*#__PURE__*/_interopDefaultCompat(_);
 const createMerge__default = /*#__PURE__*/_interopDefaultCompat(createMerge);
+const pluralize__default = /*#__PURE__*/_interopDefaultCompat(pluralize);
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -316,7 +318,7 @@ const computedPresets = {
 };
 async function handlePrecomputed(context, docs, ctx) {
   const { schema, typeName, options, db } = context;
-  if (options.skipComputed)
+  if (options.noComputed)
     return;
   const { precomputedFields, nestedTypeFields, fields } = schema[typeName];
   const computed = options.computed;
@@ -352,7 +354,7 @@ async function handlePrecomputed(context, docs, ctx) {
 }
 async function handleComputed(context, data, ctx) {
   const { schema, typeName, options, db } = context;
-  if (options.skipComputed)
+  if (options.noComputed)
     return;
   const { computedFields, nestedTypeFields, fields } = schema[typeName];
   const computed = options.computed;
@@ -977,7 +979,7 @@ function getExistingDriverInstance(entityName, drivers) {
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
-  const opts = { computed: {}, driver: memory(), features: [], ...options };
+  const opts = normalizeOptions(options);
   const db = {
     _schema: schema,
     _radsUiSlots: getRadsUiSlots(opts.features),
@@ -991,7 +993,7 @@ function generateMethods(schema, validators, options) {
   for (const key in schema) {
     effects[key] = [];
   }
-  if (!opts.skipComputed) {
+  if (!opts.noComputed) {
     verifyComputedPresense(schema, opts.computed, effects);
   }
   verifyEventSourcingSetup(schema, effects);
@@ -1024,13 +1026,18 @@ function generateMethods(schema, validators, options) {
   }
   return db;
 }
-function getDriverInstance(schema, key, driver, drivers) {
-  if (!drivers[key]) {
-    drivers[key] = getDriverInstanceInner(schema, key, driver);
+function getDriverInstance(schema, key, driver, driverInstances) {
+  if (!driverInstances[key]) {
+    driverInstances[key] = getDriverInstanceInner(schema, key, driver);
   }
-  return drivers[key];
+  return driverInstances[key];
 }
-function getDriverInstanceInner(schema, key, driverConstructor) {
+function getDriverInstanceInner(schema, key, drivers) {
+  const driverName = schema[key].decorators.entity.driver || "default";
+  const driverConstructor = drivers[driverName];
+  if (!driverConstructor) {
+    throw new Error(`Missing driver "${driverName}" for entity "${key}"`);
+  }
   const driverInstance = driverConstructor(schema, key);
   addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
@@ -1127,6 +1134,69 @@ function getRadsUiSlots(features) {
   }
   return result;
 }
+function normalizeOptions(options) {
+  let driver = options?.driver;
+  if (!driver)
+    driver = { default: memory() };
+  if (typeof driver === "function")
+    driver = { default: driver };
+  return { computed: {}, features: [], ...options, driver };
+}
+
+const restApi = (options) => (schema, entity) => {
+  const opts = {
+    baseUrl: "/api",
+    fetch: globalThis.fetch,
+    getHeaders: () => {
+      return void 0;
+    },
+    ...options
+  };
+  const fetch = opts.fetch || global.fetch;
+  async function fetchInner(...args) {
+    const [url, fetchOptions] = args;
+    const response = await fetch(url, fetchOptions);
+    const responseJson = response.status === 204 ? null : await response.json();
+    if (!response.ok) {
+      const msg = responseJson?.message || responseJson?.statusMessage || response.statusText || "Server error.";
+      const err = new Error(msg);
+      if (responseJson?.code)
+        err.code = responseJson?.code;
+      err.fetchResponseJson = responseJson;
+      throw err;
+    }
+    return responseJson;
+  }
+  const pluralEntityName = ___default.lowerFirst(pluralize__default(entity));
+  const instance = {
+    driverName: "restApi",
+    async getMany(args) {
+      args = args || {};
+      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const fetchOptions = {
+        method: "POST",
+        body: JSON.stringify(args),
+        headers: { "Content-Type": "application/json" }
+      };
+      fetchOptions.headers = { ...fetchOptions.headers, ...opts.getHeaders(url, fetchOptions) };
+      return await fetchInner(url, fetchOptions);
+    },
+    async putMany(item) {
+      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const fetchOptions = {
+        method: "PUT",
+        body: JSON.stringify({ data: item }),
+        headers: { "Content-Type": "application/json" }
+      };
+      fetchOptions.headers = { ...fetchOptions.headers, ...opts.getHeaders(url, fetchOptions) };
+      return await fetchInner(url, fetchOptions);
+    },
+    async verifyMany(args, ctx) {
+      throw new Error('Calling "verifyMany" via rest api is not supported for security reasons.');
+    }
+  };
+  return instance;
+};
 
 function entity(meta) {
   return function(classConstructor, _ctx) {
@@ -1153,15 +1223,27 @@ function computed(meta) {
   };
 }
 
-function createRads(args) {
+function createRadsDb(args) {
   args = { ...args };
   const s = args.schema || _radsDb.schema;
   const validators = generateValidators(s);
   return generateMethods(s, validators, args);
 }
+function createRadsDbClient(args) {
+  const radsDbArgs = {
+    ...args,
+    noComputed: true,
+    noCustomDrivers: true,
+    driver: restApi(args?.driver)
+  };
+  const s = radsDbArgs.schema || _radsDb.schema;
+  const validators = generateValidators(s);
+  return generateMethods(s, validators, radsDbArgs);
+}
 
 exports.computed = computed;
-exports.createRads = createRads;
+exports.createRadsDb = createRadsDb;
+exports.createRadsDbClient = createRadsDbClient;
 exports.entity = entity;
 exports.field = field;
 exports.getDriverInstance = getDriverInstance;

package/dist/index.d.ts

@@ -150,12 +150,26 @@ interface FieldDecoratorArgs {
     relation?: Function;
 }
 type DriverConstructor = (schema: Schema, entity: string) => MinimalDriver;
-interface CreateRadsArgs {
+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?: (url: string, fetchOptions: RequestInit) => Record<string, string> | undefined;
+}
+interface CreateRadsDbArgs {
     schema?: Schema;
-    driver?: DriverConstructor;
-    drivers?: Record<string, DriverConstructor>;
+    driver?: DriverConstructor | CreateRadsArgsDrivers;
     fileUploadDriver?: FileUploadDriver;
-    skipComputed?: boolean;
+    noComputed?: boolean;
+    noCustomDrivers?: boolean;
     computed?: Record<string, Record<string, Function> | {
         _entity?: {
             compute: Function;
@@ -166,6 +180,9 @@ interface CreateRadsArgs {
     context?: Record<string, any> & Omit<RadsRequestContext, 'dryRun' | 'silent'>;
     features?: RadsFeature[];
 }
+type CreateRadsDbClientArgs = Omit<CreateRadsDbArgs, 'noComputed' | 'noCustomDrivers' | 'driver'> & {
+    driver?: RestDriverOptions;
+};
 type Schema = Record<string, TypeDefinition>;
 type SchemaValidators = Record<string, (item: any) => any>;
 interface TypeDefinition {
@@ -238,7 +255,7 @@ interface ComputedContextGlobal {
     db: RadsDb;
     schema: Schema;
     validators: SchemaValidators;
-    options: CreateRadsArgs;
+    options: CreateRadsDbArgs;
     drivers: Record<string, Driver>;
     effects: Record<string, PutEffect[]>;
 }
@@ -318,7 +335,7 @@ interface RadsUiSlotDefinition {
 }
 interface RadsFeature {
     name: string;
-    radsUiSlots: Record<RadsUiSlotName, RadsUiSlotDefinition[]>;
+    radsUiSlots?: Record<RadsUiSlotName, RadsUiSlotDefinition[]>;
     init?: (db: Record<string, any>, context: ComputedContextGlobal) => void;
     enhanceEntityMethods?: (context: ComputedContext, entityMethodsObj: EntityMethods<any, any, any>) => void;
     beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<any>;
@@ -340,8 +357,18 @@ declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecora
 declare function precomputed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext | ClassDecoratorContext) => void;
 declare function computed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext | ClassDecoratorContext) => void;
 
-declare function getDriverInstance(schema: Schema, key: string, driver: DriverConstructor, drivers: Record<string, Driver>): Driver;
+declare function getDriverInstance(schema: Schema, key: string, driver: CreateRadsArgsDrivers, driverInstances: Record<string, Driver>): Driver;
 
-declare function createRads(args?: CreateRadsArgs): RadsDb;
+/**
+ * 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;
+/**
+ * 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 })`
+ */
+declare function createRadsDbClient(args?: CreateRadsDbClientArgs): RadsDb;
 
-export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, MinimalDriver, PutArgs, PutEffect, RadsFeature, RadsRequestContext, RadsUiSlotDefinition, RadsUiSlotName, RadsVitePluginOptions, Relation, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, computed, createRads, entity, field, getDriverInstance, precomputed, ui, validate };
+export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgsDrivers, CreateRadsDbArgs, CreateRadsDbClientArgs, DeepPartial, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, MinimalDriver, PutArgs, PutEffect, RadsFeature, RadsRequestContext, RadsUiSlotDefinition, RadsUiSlotName, RadsVitePluginOptions, Relation, RestDriverOptions, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, computed, createRadsDb, createRadsDbClient, entity, field, getDriverInstance, precomputed, ui, validate };

package/dist/index.mjs

@@ -3,6 +3,7 @@ import _ from 'lodash';
 import { v4 } from 'uuid';
 import createMerge from '@fastify/deepmerge';
 import { schema } from '_rads-db';
+import pluralize from 'pluralize';
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -309,7 +310,7 @@ const computedPresets = {
 };
 async function handlePrecomputed(context, docs, ctx) {
   const { schema, typeName, options, db } = context;
-  if (options.skipComputed)
+  if (options.noComputed)
     return;
   const { precomputedFields, nestedTypeFields, fields } = schema[typeName];
   const computed = options.computed;
@@ -345,7 +346,7 @@ async function handlePrecomputed(context, docs, ctx) {
 }
 async function handleComputed(context, data, ctx) {
   const { schema, typeName, options, db } = context;
-  if (options.skipComputed)
+  if (options.noComputed)
     return;
   const { computedFields, nestedTypeFields, fields } = schema[typeName];
   const computed = options.computed;
@@ -970,7 +971,7 @@ function getExistingDriverInstance(entityName, drivers) {
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
-  const opts = { computed: {}, driver: memory(), features: [], ...options };
+  const opts = normalizeOptions(options);
   const db = {
     _schema: schema,
     _radsUiSlots: getRadsUiSlots(opts.features),
@@ -984,7 +985,7 @@ function generateMethods(schema, validators, options) {
   for (const key in schema) {
     effects[key] = [];
   }
-  if (!opts.skipComputed) {
+  if (!opts.noComputed) {
     verifyComputedPresense(schema, opts.computed, effects);
   }
   verifyEventSourcingSetup(schema, effects);
@@ -1017,13 +1018,18 @@ function generateMethods(schema, validators, options) {
   }
   return db;
 }
-function getDriverInstance(schema, key, driver, drivers) {
-  if (!drivers[key]) {
-    drivers[key] = getDriverInstanceInner(schema, key, driver);
+function getDriverInstance(schema, key, driver, driverInstances) {
+  if (!driverInstances[key]) {
+    driverInstances[key] = getDriverInstanceInner(schema, key, driver);
   }
-  return drivers[key];
+  return driverInstances[key];
 }
-function getDriverInstanceInner(schema, key, driverConstructor) {
+function getDriverInstanceInner(schema, key, drivers) {
+  const driverName = schema[key].decorators.entity.driver || "default";
+  const driverConstructor = drivers[driverName];
+  if (!driverConstructor) {
+    throw new Error(`Missing driver "${driverName}" for entity "${key}"`);
+  }
   const driverInstance = driverConstructor(schema, key);
   addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
@@ -1120,6 +1126,69 @@ function getRadsUiSlots(features) {
   }
   return result;
 }
+function normalizeOptions(options) {
+  let driver = options?.driver;
+  if (!driver)
+    driver = { default: memory() };
+  if (typeof driver === "function")
+    driver = { default: driver };
+  return { computed: {}, features: [], ...options, driver };
+}
+
+const restApi = (options) => (schema, entity) => {
+  const opts = {
+    baseUrl: "/api",
+    fetch: globalThis.fetch,
+    getHeaders: () => {
+      return void 0;
+    },
+    ...options
+  };
+  const fetch = opts.fetch || global.fetch;
+  async function fetchInner(...args) {
+    const [url, fetchOptions] = args;
+    const response = await fetch(url, fetchOptions);
+    const responseJson = response.status === 204 ? null : await response.json();
+    if (!response.ok) {
+      const msg = responseJson?.message || responseJson?.statusMessage || response.statusText || "Server error.";
+      const err = new Error(msg);
+      if (responseJson?.code)
+        err.code = responseJson?.code;
+      err.fetchResponseJson = responseJson;
+      throw err;
+    }
+    return responseJson;
+  }
+  const pluralEntityName = _.lowerFirst(pluralize(entity));
+  const instance = {
+    driverName: "restApi",
+    async getMany(args) {
+      args = args || {};
+      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const fetchOptions = {
+        method: "POST",
+        body: JSON.stringify(args),
+        headers: { "Content-Type": "application/json" }
+      };
+      fetchOptions.headers = { ...fetchOptions.headers, ...opts.getHeaders(url, fetchOptions) };
+      return await fetchInner(url, fetchOptions);
+    },
+    async putMany(item) {
+      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const fetchOptions = {
+        method: "PUT",
+        body: JSON.stringify({ data: item }),
+        headers: { "Content-Type": "application/json" }
+      };
+      fetchOptions.headers = { ...fetchOptions.headers, ...opts.getHeaders(url, fetchOptions) };
+      return await fetchInner(url, fetchOptions);
+    },
+    async verifyMany(args, ctx) {
+      throw new Error('Calling "verifyMany" via rest api is not supported for security reasons.');
+    }
+  };
+  return instance;
+};
 
 function entity(meta) {
   return function(classConstructor, _ctx) {
@@ -1146,11 +1215,22 @@ function computed(meta) {
   };
 }
 
-function createRads(args) {
+function createRadsDb(args) {
   args = { ...args };
   const s = args.schema || schema;
   const validators = generateValidators(s);
   return generateMethods(s, validators, args);
 }
+function createRadsDbClient(args) {
+  const radsDbArgs = {
+    ...args,
+    noComputed: true,
+    noCustomDrivers: true,
+    driver: restApi(args?.driver)
+  };
+  const s = radsDbArgs.schema || schema;
+  const validators = generateValidators(s);
+  return generateMethods(s, validators, radsDbArgs);
+}
 
-export { computed, createRads, entity, field, getDriverInstance, precomputed, ui, validate };
+export { computed, createRadsDb, createRadsDbClient, entity, field, getDriverInstance, precomputed, ui, validate };

package/drivers/restApi.d.ts

@@ -1,12 +1,2 @@
-interface RestDriverOptions {
-    /** @default '/api' */
-    baseUrl?: string;
-    fetch?: (url: string, options?: {
-        body?: any;
-        headers?: any;
-        method?: string;
-    }) => any;
-    getHeaders?: (url: string, fetchOptions: RequestInit) => Record<string, string> | undefined;
-}
-declare const _default: (options: RestDriverOptions) => (schema: Schema, entity: string) => MinimalDriver;
+declare const _default: (options?: any) => (schema: Schema, entity: string) => MinimalDriver;
 export default _default;

package/features/cache.cjs

@@ -56,7 +56,9 @@ var _default = options => {
           handle: cacheEntityName,
           handlePlural: `${cacheEntityName}s`
         };
-        cacheDrivers[handle] = (0, _radsDb.getDriverInstance)(schema, cacheEntityName, normalizedOptions[typeName].driver, drivers);
+        cacheDrivers[handle] = (0, _radsDb.getDriverInstance)(schema, cacheEntityName, {
+          default: normalizedOptions[typeName].driver
+        }, drivers);
         cacheStatus[handle] = {
           preloadStatus: normalizedOptions[typeName].preload ? "neverLoaded" : void 0
         };

package/features/cache.mjs

@@ -38,7 +38,12 @@ export default (options) => {
           handle: cacheEntityName,
           handlePlural: `${cacheEntityName}s`
         };
-        cacheDrivers[handle] = getDriverInstance(schema, cacheEntityName, normalizedOptions[typeName].driver, drivers);
+        cacheDrivers[handle] = getDriverInstance(
+          schema,
+          cacheEntityName,
+          { default: normalizedOptions[typeName].driver },
+          drivers
+        );
         cacheStatus[handle] = { preloadStatus: normalizedOptions[typeName].preload ? "neverLoaded" : void 0 };
       }
       db.cache = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "0.1.111",
+  "version": "3.0.0",
   "files": [
     "dist",
     "drivers",