rads-db 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -31,27 +31,30 @@ function getZodSchema(zodSchemas, schema, key) {
   }
   const objectSchema = {};
   for (const fieldName in type.fields) {
-    objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, type.fields[fieldName]);
+    const shouldBeLazy = type.fields[fieldName].type === type.name;
+    objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, type.fields[fieldName], shouldBeLazy);
   }
   return zod.z.object(objectSchema);
 }
-function getFieldZodSchema(zodSchemas, schema, field) {
-  let fieldSchema = getFieldZodSchemaBase(zodSchemas, schema, field);
+function getFieldZodSchema(zodSchemas, schema, field, shouldBeLazy) {
+  let fieldSchema = getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy);
   if (!field.isRequired)
     fieldSchema = fieldSchema.optional();
   if (field.defaultValue !== void 0)
     fieldSchema = fieldSchema.default(field.defaultValue);
   return fieldSchema;
 }
-function getFieldZodSchemaBase(zodSchemas, schema, field) {
+function getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy) {
   if (field.type === "string")
     return zod.z.string();
   if (field.type === "boolean")
     return zod.z.boolean();
   if (field.type === "number")
     return zod.z.number();
-  if (schema[field.type])
-    return getZodSchema(zodSchemas, schema, field.type);
+  if (schema[field.type]) {
+    const getSchema = () => getZodSchema(zodSchemas, schema, field.type);
+    return shouldBeLazy ? zod.z.lazy(getSchema) : getSchema();
+  }
   throw new Error(`Unknown type: ${field.type}`);
 }
 
@@ -242,7 +245,7 @@ const restApi = (schema, entity, options) => {
 const driverConstructors = { memory, restApi };
 const drivers = {};
 function generateMethods(schema, validators, args) {
-  const result = { _schema: schema };
+  const db = { _schema: schema };
   for (const key in schema) {
     if (!schema[key].decorators.entity)
       continue;
@@ -250,32 +253,79 @@ function generateMethods(schema, validators, args) {
     if (!handle)
       throw new Error(`Missing handle for entity ${key}`);
     const driverInstance = getDriverInstance(schema, key, args?.driver || { type: "memory" });
-    result[handle] = {
+    db[handle] = {
       get: async (args2) => {
-        return (await driverInstance.getMany({ ...args2, maxItemCount: 1 }))?.nodes[0] || null;
+        args2 = { ...args2, maxItemCount: 1 };
+        const result = (await driverInstance.getMany(args2))?.nodes[0] || null;
+        if (args2.include)
+          await handleInclude(schema, key, args2.include, [result]);
+        return result;
       },
       getMany: async (args2) => {
-        return driverInstance.getMany(args2 || {});
+        args2 = args2 || {};
+        const result = await driverInstance.getMany(args2);
+        if (args2.include)
+          await handleInclude(schema, key, args2.include, result.nodes);
+        return result;
+      },
+      getAll: async (args2) => {
+        args2 = args2 || {};
+        const result = await driverInstance.getAll(args2);
+        if (args2.include)
+          await handleInclude(schema, key, args2.include, result);
+        return result;
       },
       put: async (item) => {
-        console.log("validating", item);
         item = validators[key](item);
         await driverInstance.putMany([item]);
         return item;
       },
       putMany: async (items) => {
-        console.log("validating", items);
         const itemsToSave = items.map((item) => validators[key](item));
         await driverInstance.putMany(itemsToSave);
         return itemsToSave;
       }
-      // putMany:
-      // deleteMany:
-      // updateMany:
-      // verifyMany:
     };
   }
-  return result;
+  return db;
+}
+async function handleInclude(schema, entityName, include, result) {
+  if (!result || !result.length || !include)
+    return;
+  const fields = schema[entityName].fields || {};
+  const relationsToInclude = ___default.keys(include).filter((key) => include[key] && schema[fields[key].type].decorators.entity);
+  const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
+    const typeName = fields[fieldName].type;
+    const type = schema[typeName];
+    if (!type)
+      throw new Error(`Cannot find entity ${typeName}`);
+    const idsToGet = /* @__PURE__ */ new Set();
+    for (const item of result) {
+      const id = item[fieldName]?.id;
+      if (!id)
+        continue;
+      idsToGet.add(id);
+    }
+    const driverInstance = getExistingDriverInstance(typeName);
+    const relatedEntities = await driverInstance.getAll({ where: { id_in: [...idsToGet] } });
+    const relatedEntitiesById = ___default.keyBy(relatedEntities, "id");
+    for (const item of result) {
+      const id = item[fieldName]?.id;
+      if (!id)
+        continue;
+      const relatedEntity = relatedEntitiesById[id];
+      if (!relatedEntity)
+        console.warn(`Cannot find ${typeName} with id "${id}" (for ${entityName}.${fieldName} with id "${item.id}")`);
+      item[fieldName] = relatedEntity;
+    }
+  });
+  await Promise.all(downloadRelationsPromises);
+}
+function getExistingDriverInstance(entityName) {
+  if (!drivers[entityName]) {
+    throw new Error(`Driver for entity ${entityName} was not found!`);
+  }
+  return drivers[entityName];
 }
 function getDriverInstance(schema, key, driver) {
   if (!drivers[key]) {
@@ -285,7 +335,30 @@ function getDriverInstance(schema, key, driver) {
 }
 function getDriverInstanceInner(schema, key, driver) {
   const driverConstructor = driverConstructors[driver.type];
-  return driverConstructor(schema, key, driver);
+  const driverInstance = driverConstructor(schema, key, driver);
+  return {
+    ...driverInstance,
+    async getAll(args) {
+      const result = [];
+      let cursor = args.cursor;
+      let maxItemCount = args.maxItemCount || 1e3;
+      if (maxItemCount < 1e3)
+        maxItemCount = 1e3;
+      for (let i = 0; i < 1e3; i++) {
+        const response = await driverInstance.getMany({ ...args, cursor, maxItemCount });
+        result.push(...response.nodes);
+        cursor = response.cursor;
+        if (cursor && cursor === response.cursor) {
+          throw new Error(
+            "Something is wrong - request for next page has returned the same cursor as before. Make sure that getMany() processes pagination correctly"
+          );
+        }
+        if (!cursor)
+          break;
+      }
+      return result;
+    }
+  };
 }
 
 function entity(meta) {

package/dist/index.d.ts

@@ -23,28 +23,32 @@ interface TypeDefinition {
     handlePlural?: string;
 }
 type MaybePromise<T> = Promise<T> | T;
-interface Driver {
+interface MinimalDriver {
     putMany: <T extends Record<string, any>>(item: T[]) => MaybePromise<void>;
     getMany: (args: GetManyArgs) => MaybePromise<{
         nodes: Record<string, any>[];
         cursor: string | null;
     }>;
 }
+interface Driver extends MinimalDriver {
+    getAll: (args: GetManyArgs) => MaybePromise<Record<string, any>[]>;
+}
 interface FieldDefinition {
     name: string;
     type: string;
     defaultValue?: any;
     isRequired?: boolean;
     comment?: string;
+    decorators?: Record<string, Record<string, any>>;
 }
-interface GetManyArgs {
-    where?: Record<string, any>;
+interface GetManyArgs extends GetArgs {
     orderBy?: string;
     maxItemCount?: number;
     cursor?: string;
 }
 interface GetArgs {
     where?: Record<string, any>;
+    include?: Record<string, any>;
 }
 interface EntityMethods<T = Record<string, any>> {
     get: (args: GetArgs) => Promise<T>;
@@ -52,6 +56,7 @@ interface EntityMethods<T = Record<string, any>> {
         nodes: T[];
         cursor: string | null;
     }>;
+    getAll: (args: GetManyArgs) => Promise<T[]>;
     put: (data: T) => Promise<T>;
     putMany: (data: T[]) => Promise<T[]>;
 }
@@ -80,4 +85,4 @@ declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecora
 declare function createRads(args: CreateRadsArgs): RadsDb;
 declare function getRestRoutes(db: radsDb, prefix?: string): Record<string, Record<string, Function>>;
 
-export { CreateRadsArgs, Driver, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GetArgs, GetManyArgs, MemoryDriverOptions, RadsDb, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, createRads, entity, field, getRestRoutes, radsDb };
+export { CreateRadsArgs, Driver, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GetArgs, GetManyArgs, MemoryDriverOptions, MinimalDriver, RadsDb, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, createRads, entity, field, getRestRoutes, radsDb };

package/dist/index.mjs

@@ -24,27 +24,30 @@ function getZodSchema(zodSchemas, schema, key) {
   }
   const objectSchema = {};
   for (const fieldName in type.fields) {
-    objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, type.fields[fieldName]);
+    const shouldBeLazy = type.fields[fieldName].type === type.name;
+    objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, type.fields[fieldName], shouldBeLazy);
   }
   return z.object(objectSchema);
 }
-function getFieldZodSchema(zodSchemas, schema, field) {
-  let fieldSchema = getFieldZodSchemaBase(zodSchemas, schema, field);
+function getFieldZodSchema(zodSchemas, schema, field, shouldBeLazy) {
+  let fieldSchema = getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy);
   if (!field.isRequired)
     fieldSchema = fieldSchema.optional();
   if (field.defaultValue !== void 0)
     fieldSchema = fieldSchema.default(field.defaultValue);
   return fieldSchema;
 }
-function getFieldZodSchemaBase(zodSchemas, schema, field) {
+function getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy) {
   if (field.type === "string")
     return z.string();
   if (field.type === "boolean")
     return z.boolean();
   if (field.type === "number")
     return z.number();
-  if (schema[field.type])
-    return getZodSchema(zodSchemas, schema, field.type);
+  if (schema[field.type]) {
+    const getSchema = () => getZodSchema(zodSchemas, schema, field.type);
+    return shouldBeLazy ? z.lazy(getSchema) : getSchema();
+  }
   throw new Error(`Unknown type: ${field.type}`);
 }
 
@@ -235,7 +238,7 @@ const restApi = (schema, entity, options) => {
 const driverConstructors = { memory, restApi };
 const drivers = {};
 function generateMethods(schema, validators, args) {
-  const result = { _schema: schema };
+  const db = { _schema: schema };
   for (const key in schema) {
     if (!schema[key].decorators.entity)
       continue;
@@ -243,32 +246,79 @@ function generateMethods(schema, validators, args) {
     if (!handle)
       throw new Error(`Missing handle for entity ${key}`);
     const driverInstance = getDriverInstance(schema, key, args?.driver || { type: "memory" });
-    result[handle] = {
+    db[handle] = {
       get: async (args2) => {
-        return (await driverInstance.getMany({ ...args2, maxItemCount: 1 }))?.nodes[0] || null;
+        args2 = { ...args2, maxItemCount: 1 };
+        const result = (await driverInstance.getMany(args2))?.nodes[0] || null;
+        if (args2.include)
+          await handleInclude(schema, key, args2.include, [result]);
+        return result;
       },
       getMany: async (args2) => {
-        return driverInstance.getMany(args2 || {});
+        args2 = args2 || {};
+        const result = await driverInstance.getMany(args2);
+        if (args2.include)
+          await handleInclude(schema, key, args2.include, result.nodes);
+        return result;
+      },
+      getAll: async (args2) => {
+        args2 = args2 || {};
+        const result = await driverInstance.getAll(args2);
+        if (args2.include)
+          await handleInclude(schema, key, args2.include, result);
+        return result;
       },
       put: async (item) => {
-        console.log("validating", item);
         item = validators[key](item);
         await driverInstance.putMany([item]);
         return item;
       },
       putMany: async (items) => {
-        console.log("validating", items);
         const itemsToSave = items.map((item) => validators[key](item));
         await driverInstance.putMany(itemsToSave);
         return itemsToSave;
       }
-      // putMany:
-      // deleteMany:
-      // updateMany:
-      // verifyMany:
     };
   }
-  return result;
+  return db;
+}
+async function handleInclude(schema, entityName, include, result) {
+  if (!result || !result.length || !include)
+    return;
+  const fields = schema[entityName].fields || {};
+  const relationsToInclude = _.keys(include).filter((key) => include[key] && schema[fields[key].type].decorators.entity);
+  const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
+    const typeName = fields[fieldName].type;
+    const type = schema[typeName];
+    if (!type)
+      throw new Error(`Cannot find entity ${typeName}`);
+    const idsToGet = /* @__PURE__ */ new Set();
+    for (const item of result) {
+      const id = item[fieldName]?.id;
+      if (!id)
+        continue;
+      idsToGet.add(id);
+    }
+    const driverInstance = getExistingDriverInstance(typeName);
+    const relatedEntities = await driverInstance.getAll({ where: { id_in: [...idsToGet] } });
+    const relatedEntitiesById = _.keyBy(relatedEntities, "id");
+    for (const item of result) {
+      const id = item[fieldName]?.id;
+      if (!id)
+        continue;
+      const relatedEntity = relatedEntitiesById[id];
+      if (!relatedEntity)
+        console.warn(`Cannot find ${typeName} with id "${id}" (for ${entityName}.${fieldName} with id "${item.id}")`);
+      item[fieldName] = relatedEntity;
+    }
+  });
+  await Promise.all(downloadRelationsPromises);
+}
+function getExistingDriverInstance(entityName) {
+  if (!drivers[entityName]) {
+    throw new Error(`Driver for entity ${entityName} was not found!`);
+  }
+  return drivers[entityName];
 }
 function getDriverInstance(schema, key, driver) {
   if (!drivers[key]) {
@@ -278,7 +328,30 @@ function getDriverInstance(schema, key, driver) {
 }
 function getDriverInstanceInner(schema, key, driver) {
   const driverConstructor = driverConstructors[driver.type];
-  return driverConstructor(schema, key, driver);
+  const driverInstance = driverConstructor(schema, key, driver);
+  return {
+    ...driverInstance,
+    async getAll(args) {
+      const result = [];
+      let cursor = args.cursor;
+      let maxItemCount = args.maxItemCount || 1e3;
+      if (maxItemCount < 1e3)
+        maxItemCount = 1e3;
+      for (let i = 0; i < 1e3; i++) {
+        const response = await driverInstance.getMany({ ...args, cursor, maxItemCount });
+        result.push(...response.nodes);
+        cursor = response.cursor;
+        if (cursor && cursor === response.cursor) {
+          throw new Error(
+            "Something is wrong - request for next page has returned the same cursor as before. Make sure that getMany() processes pagination correctly"
+          );
+        }
+        if (!cursor)
+          break;
+      }
+      return result;
+    }
+  };
 }
 
 function entity(meta) {

package/drivers/memory.cjs

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const operatorFns = {
+  eq: (x, w) => x === w,
+  ieq: (x, w) => x?.toLowerCase() === w?.toLowerCase(),
+  in: (x, w) => w.includes(x),
+  startsWith: (x, w) => x?.startsWith(w),
+  istartsWith: (x, w) => x?.toLowerCase()?.startsWith(w.toLowerCase()),
+  endsWith: (x, w) => x?.endsWith(w),
+  iendsWith: (x, w) => x?.toLowerCase()?.endsWith(w.toLowerCase()),
+  contains: (x, w) => x?.includes(w),
+  icontains: (x, w) => x?.toLowerCase()?.includes(w.toLowerCase()),
+  isNull: (x, w) => {
+    if (w === true) return x == null;
+    if (w === false) return x != null;
+    return true;
+  },
+  gt: (x, w) => x > w,
+  gte: (x, w) => x >= w,
+  lt: (x, w) => x < w,
+  lte: (x, w) => x <= w,
+  between: (x, w) => {
+    const {
+      start,
+      end
+    } = w || {};
+    let result = true;
+    if (start) result = result && x >= start;
+    if (end) result = result && x >= end;
+    return result;
+  }
+};
+var _default = (schema, entity) => {
+  const cache = {};
+  function getItemById(id) {
+    return cache[id] ?? null;
+  }
+  function getItemByIds(ids) {
+    return ids.map(id => cache[id]);
+  }
+  return {
+    // getItemById,
+    // getItemByIds,
+    putMany(items) {
+      for (const item of items) {
+        if (!item?.id) throw new Error(`You must provide an id`);
+        cache[item.id] = item;
+      }
+    },
+    getMany(args) {
+      args = args || {};
+      const where = args.where || {};
+      const whereKeys = _lodash.default.keys(where);
+      if (whereKeys.length === 1) {
+        if (whereKeys[0] === "id") return {
+          nodes: [getItemById(where.id)].filter(x => x),
+          cursor: null
+        };
+        if (whereKeys[0] === "id_in") return {
+          nodes: getItemByIds(where.id_in).filter(x => x),
+          cursor: null
+        };
+      }
+      return queryArray(Object.values(cache), args);
+    }
+  };
+};
+module.exports = _default;
+function queryArray(array, args) {
+  if (!array) return array;
+  let result = array;
+  const {
+    where,
+    orderByProperty,
+    orderByDirection,
+    maxItemCount,
+    cursor
+  } = prepareArgs(args);
+  const startIndex = Number(cursor) || 0;
+  const endIndex = startIndex + maxItemCount;
+  const f = getFilter(where);
+  if (f) result = result.filter(f);
+  if (orderByProperty) result = _lodash.default.orderBy(result, [orderByProperty], [orderByDirection]);
+  if (maxItemCount) result = result.slice(startIndex, endIndex);
+  const newCursor = endIndex >= array.length ? null : endIndex;
+  return {
+    nodes: result,
+    cursor: newCursor?.toString() || null
+  };
+}
+function getFilter(where, namePrefix = "") {
+  if (_lodash.default.isEmpty(where)) return null;
+  const andClauses = [];
+  for (const key in where) {
+    const [nameFromWhere, operator] = getWhereNameOperatorPair(key);
+    const name = [namePrefix, nameFromWhere].filter(x => x).join(".");
+    const whereVal = where[key];
+    if (whereVal == null) continue;
+    const f = getFilterInner(operator, whereVal, name, namePrefix);
+    if (f) andClauses.push(f);
+  }
+  if (andClauses.length === 0) return null;
+  return x => andClauses.every(ac => ac(x));
+}
+function getWhereNameOperatorPair(whereKey) {
+  if (whereKey.startsWith("_type")) {
+    const operator = whereKey.split("_")[2];
+    return ["_type", operator];
+  }
+  return whereKey.split("_");
+}
+function getFilterInner(operator, whereVal, name, namePrefix) {
+  if (!operator && _lodash.default.isObject(whereVal)) {
+    return getFilter(whereVal, name);
+  }
+  if (operator === "some") {
+    const f = getFilter(whereVal, namePrefix);
+    return f && (x => {
+      const val = _lodash.default.get(x, name);
+      return val === void 0 || val?.some(f);
+    });
+  }
+  if (operator === "none") {
+    const f = getFilter(whereVal, namePrefix);
+    return f && (x => !_lodash.default.get(x, name)?.some(f));
+  }
+  if (operator === "and") {
+    if (!_lodash.default.isArray(whereVal)) throw new Error(`Value for where._and must be an array`);
+    const newAndClauses = whereVal.map(whereValAnd => getFilter(whereValAnd, namePrefix)).flatMap(x => x ? [x] : []);
+    if (!newAndClauses.length) return null;
+    return x => newAndClauses.every(ac => ac(x));
+  }
+  if (operator === "not") {
+    const f = getFilter(whereVal, namePrefix);
+    return f && (x => !f(x));
+  }
+  if (operator === "or") {
+    if (!_lodash.default.isArray(whereVal)) throw new Error(`Value for where._or must be an array`);
+    const orClauses = whereVal.map(whereValOr => getFilter(whereValOr, namePrefix)).flatMap(x => x ? [x] : []);
+    if (!orClauses.length) return null;
+    return x => orClauses.some(oc => oc(x));
+  }
+  const operatorFn = operatorFns[operator || "eq"];
+  if (operatorFn) {
+    return x => operatorFn(_lodash.default.get(x, name), whereVal);
+  }
+  console.warn(`[rads-cache] Operator not supported: ${operator || "eq"}`);
+  return null;
+}
+function prepareArgs(args) {
+  args = args || {};
+  const where = {
+    ...args.where
+  };
+  let orderBy = args.orderBy || "";
+  if (Array.isArray(orderBy)) orderBy = orderBy[0] || "";
+  const orderByParts = orderBy.split("_");
+  const orderByProperty = orderByParts.slice(0, -1).join(".");
+  const orderByDirection = orderByParts.slice(-1)[0];
+  let maxItemCount = args.maxItemCount;
+  maxItemCount = maxItemCount || 100;
+  return {
+    where,
+    orderByProperty,
+    orderByDirection,
+    maxItemCount,
+    cursor: args.cursor
+  };
+}

package/drivers/memory.d.ts

@@ -0,0 +1,8 @@
+declare const _default: (schema: Schema, entity: string) => {
+    putMany<T extends Record<string, any>>(items: T[]): void;
+    getMany(args?: any): {
+        nodes: Record<string, any>[];
+        cursor: string | null;
+    };
+};
+export default _default;