rads-db 0.1.109 → 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,9 +979,10 @@ 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),
     uploadFile(args) {
       if (!opts.fileUploadDriver)
         throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
@@ -990,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);
@@ -1023,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) {
@@ -1109,6 +1117,86 @@ function addDryRunSupport(driverInstance, entity) {
     return putMany(data, ctx);
   };
 }
+function getRadsUiSlots(features) {
+  const result = {};
+  if (!features)
+    return result;
+  for (const f of features) {
+    if (!f.radsUiSlots)
+      continue;
+    for (const key in f.radsUiSlots) {
+      const slotKey = key;
+      if (!result[slotKey])
+        result[slotKey] = f.radsUiSlots[slotKey];
+      else
+        result[slotKey] = [...f.radsUiSlots[slotKey], ...result[slotKey]];
+    }
+  }
+  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) {
@@ -1135,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[]>;
 }
@@ -304,8 +321,21 @@ interface FileSystemNode {
     size?: number;
     type: 'blob' | 'tree';
 }
+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, any>) => void;
     beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<any>;
@@ -327,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, 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,9 +971,10 @@ 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),
     uploadFile(args) {
       if (!opts.fileUploadDriver)
         throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
@@ -983,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);
@@ -1016,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) {
@@ -1102,6 +1109,86 @@ function addDryRunSupport(driverInstance, entity) {
     return putMany(data, ctx);
   };
 }
+function getRadsUiSlots(features) {
+  const result = {};
+  if (!features)
+    return result;
+  for (const f of features) {
+    if (!f.radsUiSlots)
+      continue;
+    for (const key in f.radsUiSlots) {
+      const slotKey = key;
+      if (!result[slotKey])
+        result[slotKey] = f.radsUiSlots[slotKey];
+      else
+        result[slotKey] = [...f.radsUiSlots[slotKey], ...result[slotKey]];
+    }
+  }
+  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) {
@@ -1128,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/fileUploadDrivers/supabaseStorage.cjs

@@ -17,7 +17,10 @@ var _default = options => {
       const {
         data,
         error
-      } = await bucketClient.upload(args.fileName, args.blob, {});
+      } = await bucketClient.upload(args.fileName, args.blob, {
+        ...options.uploadOptions,
+        ...args.options
+      });
       if (error) throw error;
       const resultPath = data?.path;
       if (!resultPath) return {

package/fileUploadDrivers/supabaseStorage.d.ts

@@ -4,4 +4,5 @@ export default _default;
 interface SupabaseFileUploadDriverOptions {
     supabase: SupabaseClient;
     defaultBucket?: string;
+    uploadOptions?: Parameters<ReturnType<SupabaseClient['storage']['from']>['upload']>['2'];
 }

package/fileUploadDrivers/supabaseStorage.mjs

@@ -7,7 +7,10 @@ export default (options) => {
     driverName: "supabase",
     async uploadFile(args) {
       const bucketClient = supabase.storage.from(args.containerName || defaultBucket);
-      const { data, error } = await bucketClient.upload(args.fileName, args.blob, {});
+      const { data, error } = await bucketClient.upload(args.fileName, args.blob, {
+        ...options.uploadOptions,
+        ...args.options
+      });
       if (error)
         throw error;
       const resultPath = data?.path;

package/integrations/restEndpoints.cjs

@@ -98,6 +98,9 @@ function getRadsTunnelHandler(options) {
     if (method === "_schema") {
       return db._schema;
     }
+    if (method === "_radsUiSlots") {
+      return db._radsUiSlots;
+    }
     if (method === "getProcessInfo") {
       return {};
     }

package/integrations/restEndpoints.mjs

@@ -65,6 +65,9 @@ export function getRadsTunnelHandler(options) {
     if (method === "_schema") {
       return db._schema;
     }
+    if (method === "_radsUiSlots") {
+      return db._radsUiSlots;
+    }
     if (method === "getProcessInfo") {
       return {};
     }

package/package.json

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