rads-db 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# Introduction
+
+When you work with the databases
+
+## What is ORM?
+
+ORM is acronym for “Object Relational Mapping”. It is a library that helps developers to work with the database without
+leaving comfort of their programming language.
+
+In other words, if your database is e.g. SQL, instead of writing raw sql queries and parsing results, you can functions
+provided by ORM library for your programming language (e.g. Typescript).
+
+```jsx
+// Without ORM:
+const data = db.query("select * from users where login like '%admin%'")
+// With ORM:
+const data = orm.users.get({ where: { login_contains: 'admin' } })
+```
+
+Popular ORMs:
+
+- Entity Framework (C#/.net)
+- ServiceStack.OrmLite (C#/.net)
+- Hibernate (Java)
+- Prisma (TS)
+- Drizzle (TS)
+- TypeORM (TS)
+- MikroORM (TS)
+- Sequelize (TS)
+
+[Here](https://www.prisma.io/docs/concepts/overview/prisma-in-your-stack/is-prisma-an-orm) is a good article from Prisma
+providing detailed overview of how ORMs work.
+
+## What are the downsides of using ORM?
+
+ORM hides database complexity from the developer, but that has a price.
+
+- “Simple” ORMs (e.g. Prisma) quickly encounter limitations - e.g. sql queries that cannot be represented by ORM.
+- “Complex” ORMs that try to support full set of features (e.g. Entity Framework) add their own complexity and introduce
+  mental load on top of managing SQL
+
+Consensus among the developer community is to use “simple” ORM, and use raw queries when ORM capabilities is not enough.
+
+## Ok, ORMs are useful. Why create new one?
+
+We wanted to have features that are not supported in current ORMs:
+
+- [This](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) article gives good overview

package/dist/index.cjs

@@ -0,0 +1,327 @@
+'use strict';
+
+const zod = require('zod');
+const _ = require('lodash');
+const pluralize = require('pluralize');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const ___default = /*#__PURE__*/_interopDefaultCompat(_);
+const pluralize__default = /*#__PURE__*/_interopDefaultCompat(pluralize);
+
+function generateValidators(schema) {
+  const zodSchemas = {};
+  for (const key in schema) {
+    if (!zodSchemas[key])
+      zodSchemas[key] = getZodSchema(zodSchemas, schema, key);
+  }
+  const result = {};
+  for (const key in zodSchemas) {
+    result[key] = (value) => zodSchemas[key].parse(value);
+  }
+  return result;
+}
+function getZodSchema(zodSchemas, schema, key) {
+  if (zodSchemas[key])
+    return zodSchemas[key];
+  const type = schema[key];
+  if (type.enumValues) {
+    const enums = ___default.fromPairs(type.enumValues.map((x) => [x, x]));
+    return zod.z.nativeEnum(enums);
+  }
+  const objectSchema = {};
+  for (const fieldName in type.fields) {
+    objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, type.fields[fieldName]);
+  }
+  return zod.z.object(objectSchema);
+}
+function getFieldZodSchema(zodSchemas, schema, field) {
+  let fieldSchema = getFieldZodSchemaBase(zodSchemas, schema, field);
+  if (!field.isRequired)
+    fieldSchema = fieldSchema.optional();
+  if (field.defaultValue !== void 0)
+    fieldSchema = fieldSchema.default(field.defaultValue);
+  return fieldSchema;
+}
+function getFieldZodSchemaBase(zodSchemas, schema, field) {
+  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);
+  throw new Error(`Unknown type: ${field.type}`);
+}
+
+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;
+  }
+};
+const memory = (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 = ___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);
+    }
+  };
+};
+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 = ___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 (___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 && ___default.isObject(whereVal)) {
+    return getFilter(whereVal, name);
+  }
+  if (operator === "some") {
+    const f = getFilter(whereVal, namePrefix);
+    return f && ((x) => {
+      const val = ___default.get(x, name);
+      return val === void 0 || val?.some(f);
+    });
+  }
+  if (operator === "none") {
+    const f = getFilter(whereVal, namePrefix);
+    return f && ((x) => !___default.get(x, name)?.some(f));
+  }
+  if (operator === "and") {
+    if (!___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 (!___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(___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 };
+}
+
+const restApi = (schema, entity, options) => {
+  options = { baseUrl: "/api", fetch: globalThis.fetch, ...options };
+  const fetch = options.fetch || global.fetch;
+  if (!options.fetch)
+    throw new Error('Please provide "fetch" argument to rest driver definition');
+  const pluralEntityName = ___default.lowerFirst(pluralize__default(entity));
+  return {
+    async getMany(args) {
+      const response = await fetch(`${options.baseUrl}/${pluralEntityName}`, {
+        method: "POST",
+        body: JSON.stringify(args)
+      });
+      return await response?.json();
+    },
+    async putMany(item) {
+      await fetch(`${options.baseUrl}/${pluralEntityName}`, {
+        method: "PUT",
+        body: JSON.stringify({ data: item })
+      });
+    }
+  };
+};
+
+const driverConstructors = { memory, restApi };
+const drivers = {};
+function generateMethods(schema, validators, args) {
+  const result = { _schema: schema };
+  for (const key in schema) {
+    if (!schema[key].decorators.entity)
+      continue;
+    const { handle } = schema[key];
+    if (!handle)
+      throw new Error(`Missing handle for entity ${key}`);
+    const driverInstance = getDriverInstance(schema, key, args?.driver || { type: "memory" });
+    result[handle] = {
+      get: async (args2) => {
+        return (await driverInstance.getMany({ ...args2, maxItemCount: 1 }))?.nodes[0] || null;
+      },
+      getMany: async (args2) => {
+        return driverInstance.getMany(args2 || {});
+      },
+      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;
+}
+function getDriverInstance(schema, key, driver) {
+  if (!drivers[key]) {
+    drivers[key] = getDriverInstanceInner(schema, key, driver);
+  }
+  return drivers[key];
+}
+function getDriverInstanceInner(schema, key, driver) {
+  const driverConstructor = driverConstructors[driver.type];
+  return driverConstructor(schema, key, driver);
+}
+
+function entity(meta) {
+  return function(classConstructor, _ctx) {
+  };
+}
+function field(meta) {
+  return function(a, b) {
+  };
+}
+
+function createRads(args) {
+  const { schema } = args;
+  const validators = generateValidators(schema);
+  return generateMethods(schema, validators, args);
+}
+function getRestRoutes(db, prefix = "/") {
+  const routes = {};
+  const schema = db._schema;
+  for (const key in schema) {
+    const entity = schema[key];
+    if (!entity.decorators?.entity)
+      continue;
+    routes[`${prefix}${entity.handle}`] = {
+      POST: (args) => db[entity.handle].get(args),
+      PUT: (args) => db[entity.handle].put(args?.data)
+    };
+    routes[`${prefix}${entity.handlePlural}`] = {
+      POST: (args) => db[entity.handle].getMany(args),
+      PUT: (args) => db[entity.handle].putMany(args?.data)
+    };
+  }
+  return routes;
+}
+
+exports.createRads = createRads;
+exports.entity = entity;
+exports.field = field;
+exports.getRestRoutes = getRestRoutes;

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { HTTPMethod } from 'h3';
+
+interface EntityDecoratorArgs {
+    driver?: string;
+}
+interface FieldDecoratorArgs {
+    relation?: Function;
+}
+interface CreateRadsArgs {
+    schema: Schema;
+    driver?: DriverOptions;
+    drivers?: Record<string, DriverOptions>;
+    defaultDriver?: string;
+}
+type Schema = Record<string, TypeDefinition>;
+type SchemaValidators = Record<string, (item: any) => any>;
+interface TypeDefinition {
+    name: string;
+    decorators: Record<string, Record<string, any>>;
+    fields?: Record<string, FieldDefinition>;
+    enumValues?: string[];
+    handle?: string;
+    handlePlural?: string;
+}
+type MaybePromise<T> = Promise<T> | T;
+interface Driver {
+    putMany: <T extends Record<string, any>>(item: T[]) => MaybePromise<void>;
+    getMany: (args: GetManyArgs) => MaybePromise<{
+        nodes: Record<string, any>[];
+        cursor: string | null;
+    }>;
+}
+interface FieldDefinition {
+    name: string;
+    type: string;
+    defaultValue?: any;
+    isRequired?: boolean;
+    comment?: string;
+}
+interface GetManyArgs {
+    where?: Record<string, any>;
+    orderBy?: string;
+    maxItemCount?: number;
+    cursor?: string;
+}
+interface GetArgs {
+    where?: Record<string, any>;
+}
+interface EntityMethods<T = Record<string, any>> {
+    get: (args: GetArgs) => Promise<T>;
+    getMany: (args: GetManyArgs) => Promise<{
+        nodes: T[];
+        cursor: string | null;
+    }>;
+    put: (data: T) => Promise<T>;
+    putMany: (data: T[]) => Promise<T[]>;
+}
+type radsDb = Record<string, EntityMethods>;
+interface RestDriverOptions {
+    type: 'restApi';
+    /** @default '/api' */
+    baseUrl?: string;
+    fetch?: (url: string, options?: {
+        body?: any;
+        headers?: any;
+        method?: HTTPMethod;
+    }) => any;
+}
+interface MemoryDriverOptions {
+    type: 'memory';
+}
+type DriverOptions = RestDriverOptions | MemoryDriverOptions;
+interface RadsDb {
+    [key: string]: EntityMethods;
+}
+
+declare function entity(meta?: EntityDecoratorArgs): (classConstructor: Function, _ctx?: ClassDecoratorContext<any>) => void;
+declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext) => void;
+
+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 };

package/dist/index.mjs

@@ -0,0 +1,317 @@
+import { z } from 'zod';
+import _ from 'lodash';
+import pluralize from 'pluralize';
+
+function generateValidators(schema) {
+  const zodSchemas = {};
+  for (const key in schema) {
+    if (!zodSchemas[key])
+      zodSchemas[key] = getZodSchema(zodSchemas, schema, key);
+  }
+  const result = {};
+  for (const key in zodSchemas) {
+    result[key] = (value) => zodSchemas[key].parse(value);
+  }
+  return result;
+}
+function getZodSchema(zodSchemas, schema, key) {
+  if (zodSchemas[key])
+    return zodSchemas[key];
+  const type = schema[key];
+  if (type.enumValues) {
+    const enums = _.fromPairs(type.enumValues.map((x) => [x, x]));
+    return z.nativeEnum(enums);
+  }
+  const objectSchema = {};
+  for (const fieldName in type.fields) {
+    objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, type.fields[fieldName]);
+  }
+  return z.object(objectSchema);
+}
+function getFieldZodSchema(zodSchemas, schema, field) {
+  let fieldSchema = getFieldZodSchemaBase(zodSchemas, schema, field);
+  if (!field.isRequired)
+    fieldSchema = fieldSchema.optional();
+  if (field.defaultValue !== void 0)
+    fieldSchema = fieldSchema.default(field.defaultValue);
+  return fieldSchema;
+}
+function getFieldZodSchemaBase(zodSchemas, schema, field) {
+  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);
+  throw new Error(`Unknown type: ${field.type}`);
+}
+
+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;
+  }
+};
+const memory = (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 = _.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);
+    }
+  };
+};
+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 = _.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 (_.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 && _.isObject(whereVal)) {
+    return getFilter(whereVal, name);
+  }
+  if (operator === "some") {
+    const f = getFilter(whereVal, namePrefix);
+    return f && ((x) => {
+      const val = _.get(x, name);
+      return val === void 0 || val?.some(f);
+    });
+  }
+  if (operator === "none") {
+    const f = getFilter(whereVal, namePrefix);
+    return f && ((x) => !_.get(x, name)?.some(f));
+  }
+  if (operator === "and") {
+    if (!_.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 (!_.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(_.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 };
+}
+
+const restApi = (schema, entity, options) => {
+  options = { baseUrl: "/api", fetch: globalThis.fetch, ...options };
+  const fetch = options.fetch || global.fetch;
+  if (!options.fetch)
+    throw new Error('Please provide "fetch" argument to rest driver definition');
+  const pluralEntityName = _.lowerFirst(pluralize(entity));
+  return {
+    async getMany(args) {
+      const response = await fetch(`${options.baseUrl}/${pluralEntityName}`, {
+        method: "POST",
+        body: JSON.stringify(args)
+      });
+      return await response?.json();
+    },
+    async putMany(item) {
+      await fetch(`${options.baseUrl}/${pluralEntityName}`, {
+        method: "PUT",
+        body: JSON.stringify({ data: item })
+      });
+    }
+  };
+};
+
+const driverConstructors = { memory, restApi };
+const drivers = {};
+function generateMethods(schema, validators, args) {
+  const result = { _schema: schema };
+  for (const key in schema) {
+    if (!schema[key].decorators.entity)
+      continue;
+    const { handle } = schema[key];
+    if (!handle)
+      throw new Error(`Missing handle for entity ${key}`);
+    const driverInstance = getDriverInstance(schema, key, args?.driver || { type: "memory" });
+    result[handle] = {
+      get: async (args2) => {
+        return (await driverInstance.getMany({ ...args2, maxItemCount: 1 }))?.nodes[0] || null;
+      },
+      getMany: async (args2) => {
+        return driverInstance.getMany(args2 || {});
+      },
+      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;
+}
+function getDriverInstance(schema, key, driver) {
+  if (!drivers[key]) {
+    drivers[key] = getDriverInstanceInner(schema, key, driver);
+  }
+  return drivers[key];
+}
+function getDriverInstanceInner(schema, key, driver) {
+  const driverConstructor = driverConstructors[driver.type];
+  return driverConstructor(schema, key, driver);
+}
+
+function entity(meta) {
+  return function(classConstructor, _ctx) {
+  };
+}
+function field(meta) {
+  return function(a, b) {
+  };
+}
+
+function createRads(args) {
+  const { schema } = args;
+  const validators = generateValidators(schema);
+  return generateMethods(schema, validators, args);
+}
+function getRestRoutes(db, prefix = "/") {
+  const routes = {};
+  const schema = db._schema;
+  for (const key in schema) {
+    const entity = schema[key];
+    if (!entity.decorators?.entity)
+      continue;
+    routes[`${prefix}${entity.handle}`] = {
+      POST: (args) => db[entity.handle].get(args),
+      PUT: (args) => db[entity.handle].put(args?.data)
+    };
+    routes[`${prefix}${entity.handlePlural}`] = {
+      POST: (args) => db[entity.handle].getMany(args),
+      PUT: (args) => db[entity.handle].putMany(args?.data)
+    };
+  }
+  return routes;
+}
+
+export { createRads, entity, field, getRestRoutes };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "rads-db",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./drivers/*": {
+      "types": "./drivers/*.d.ts",
+      "import": "./drivers/*.mjs",
+      "require": "./drivers/*.cjs"
+    },
+    "./integrations/*": {
+      "types": "./integrations/*.d.ts",
+      "import": "./integrations/*.mjs",
+      "require": "./integrations/*.cjs"
+    }
+  },
+  "version": "0.1.0",
+  "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "peerDependencies": {
+    "h3": "*",
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^0.31.0",
+    "tsup": "^6.7.0",
+    "unbuild": "^1.2.1",
+    "vite": "^4.0.0",
+    "vitest": "^0.31.0"
+  },
+  "dependencies": {
+    "@azure/cosmos": "^3.17.3",
+    "@nuxt/kit": "^3.5.1",
+    "@types/lodash": "4.14.191",
+    "dataloader": "^2.2.2",
+    "lodash": "link:@types\\lodash",
+    "pluralize": "^8.0.0",
+    "rads-db": "^0.1.0",
+    "zod": "^3.21.4"
+  },
+  "scripts": {
+    "test": "vitest",
+    "dev": "pnpm install --frozen-lockfile && vitest --ui",
+    "build": "unbuild"
+  }
+}