rads-db 0.1.0 → 0.1.1

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;

package/drivers/memory.mjs

@@ -0,0 +1,161 @@
+import _ from "lodash";
+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;
+  }
+};
+export 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 = _.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 };
+}

package/drivers/restApi.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _pluralize = _interopRequireDefault(require("pluralize"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = (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 = _lodash.default.lowerFirst((0, _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
+        })
+      });
+    }
+  };
+};
+module.exports = _default;

package/drivers/restApi.d.ts

@@ -0,0 +1,5 @@
+declare const _default: (schema: Schema, entity: string, options: RestDriverOptions) => {
+    getMany(args: GetManyArgs): Promise<any>;
+    putMany<T extends Record<string, any>>(item: T): Promise<void>;
+};
+export default _default;

package/drivers/restApi.mjs

@@ -0,0 +1,24 @@
+import _ from "lodash";
+import pluralize from "pluralize";
+export default (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 })
+      });
+    }
+  };
+};

package/integrations/node.cjs

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseSchema = parseSchema;
+var _typescript = require("typescript");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _pluralize = _interopRequireDefault(require("pluralize"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function parseSchema(typescriptFiles) {
+  const result = {};
+  const typesMap = {};
+  for (const key in typescriptFiles) {
+    const text = typescriptFiles[key];
+    const sourceFile = (0, _typescript.createSourceFile)(`${key}.ts`, text, _typescript.ScriptTarget.Latest);
+    const classDeclarations = getClassDeclarations(sourceFile);
+    for (const cd of classDeclarations) {
+      const nameNode = cd.name;
+      if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
+      const name = nameNode.text;
+      typesMap[name] = {
+        name,
+        node: cd,
+        sourceFile
+      };
+    }
+  }
+  for (const key in typesMap) {
+    const {
+      node,
+      sourceFile
+    } = typesMap[key];
+    const parsedClass = parseType(node, {
+      typesMap,
+      sourceFile
+    });
+    if (parsedClass.name !== key) throw new Error(`File name must correspond to exported class name ("${key}", "${parsedClass.name}")`);
+    result[key] = parsedClass;
+  }
+  for (const key in result) {
+    const isExtendingType = result[key].isExtending;
+    if (!isExtendingType) continue;
+    if (!result[isExtendingType]) throw new Error(`Unknown type: "${isExtendingType}"`);
+    result[key].fields = {
+      ...result[isExtendingType].fields,
+      ...result[key].fields
+    };
+    result[key].decorators = {
+      ...result[isExtendingType].decorators,
+      ...result[key].decorators
+    };
+    if (result[key].decorators.entity && !result[key].fields?.id) {
+      throw new Error(`Entity "${key}" must have an id`);
+    }
+  }
+  return result;
+}
+function parseType(typeDeclaration, ctx) {
+  const {
+    modifiers
+  } = typeDeclaration;
+  const nameNode = typeDeclaration.name;
+  if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
+  const name = nameNode.text;
+  const comment = typeDeclaration.jsDoc?.[0]?.comment;
+  const decoratorNodes = modifiers?.filter(x => x.kind === _typescript.SyntaxKind.Decorator) || [];
+  const decoratorsArray = decoratorNodes?.map(x => parseDecorator(x, ctx));
+  const decorators = {};
+  for (const d of decoratorsArray) {
+    decorators[d.name] = d.args;
+  }
+  if (typeDeclaration.kind === _typescript.SyntaxKind.ClassDeclaration) {
+    const classDeclaration = typeDeclaration;
+    const {
+      members,
+      heritageClauses
+    } = classDeclaration;
+    const isExtendingExpr = heritageClauses?.[0]?.types?.[0]?.expression;
+    const isExtending = isExtendingExpr?.text;
+    for (const m of members) {
+      if (m.kind !== _typescript.SyntaxKind.PropertyDeclaration) {
+        throw new Error(`Unexpected class member - only properties are allowed("${m.getText(ctx.sourceFile)}")`);
+      }
+    }
+    const fieldsArray = members.map(m => parseClassMember(m, ctx));
+    const fields = {};
+    for (const f of fieldsArray) {
+      fields[f.name] = f;
+    }
+    const handle = _lodash.default.lowerFirst(name);
+    const handlePlural = (0, _pluralize.default)(handle);
+    return {
+      name,
+      handle,
+      handlePlural,
+      decorators,
+      fields,
+      isExtending,
+      comment
+    };
+  }
+  if (typeDeclaration.kind === _typescript.SyntaxKind.TypeAliasDeclaration) {
+    const typeAliasDeclaration = typeDeclaration;
+    if (typeAliasDeclaration.type.kind !== _typescript.SyntaxKind.UnionType) throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}`);
+    const typeAliasValue = typeAliasDeclaration.type;
+    const enumValues = typeAliasValue.types.map(node => {
+      if (node.kind !== _typescript.SyntaxKind.LiteralType) {
+        throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}`);
+      }
+      const {
+        literal
+      } = node;
+      if (literal.kind !== _typescript.SyntaxKind.StringLiteral) throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}`);
+      return literal.text;
+    });
+    if (typeDeclaration) return {
+      name,
+      decorators,
+      enumValues,
+      comment
+    };
+  }
+  throw new Error(`Unexpected type kind - "${name}"`);
+}
+function parseClassMember(node, ctx) {
+  const supportedPrimitiveTypes = ["string", "number", "boolean"];
+  const name = node.name.getText(ctx.sourceFile);
+  const defaultValueDescription = parseLiteralNode(node.initializer, ctx);
+  const defaultValue = defaultValueDescription?.value;
+  const isRequired = !!node.exclamationToken || !!defaultValueDescription;
+  const comment = node.jsDoc?.[0]?.comment;
+  const type = node.type?.getText(ctx.sourceFile) ?? defaultValueDescription?.type;
+  if (!type) throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
+  if (!supportedPrimitiveTypes.includes(type) && !ctx.typesMap[type]) throw new Error(`Unexpected property type: '${type}'`);
+  if (defaultValueDescription) {
+    if (supportedPrimitiveTypes.includes(type) && defaultValueDescription.type !== type) {
+      throw new Error(`Default value type is different from field type: '${type}'`);
+    }
+    const enumValues = ctx.typesMap[type]?.enumValues;
+    if (enumValues && enumValues.includes(defaultValue)) {
+      throw new Error(`Default value type is different from field type: '${type}'`);
+    }
+  }
+  return {
+    type,
+    defaultValue,
+    name,
+    isRequired,
+    comment
+  };
+}
+function parseDecorator(decoratorNode, ctx) {
+  const expr = decoratorNode.expression;
+  if (expr.kind !== _typescript.SyntaxKind.CallExpression) throw new Error(`Unexpected decorator format: "${expr.getText(ctx.sourceFile)}"`);
+  const nameNode = expr.expression;
+  if (nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error(`Unexpected decorator format: "${nameNode.getText(ctx.sourceFile)}"`);
+  return {
+    name: nameNode.text,
+    args: parseDecoratorArguments(expr, ctx)
+  };
+}
+function parseDecoratorArguments(expr, ctx) {
+  const args = expr.arguments;
+  if (args.length === 0) return {};
+  if (args.length > 1) throw new Error(`Too many arguments - one expected: "${expr.getText(ctx.sourceFile)}"`);
+  const arg = args[0];
+  return parseLiteralNode(arg, ctx)?.value ?? {};
+}
+function parseLiteralNode(expr, ctx) {
+  if (!expr) return void 0;
+  if (expr.kind === _typescript.SyntaxKind.StringLiteral) return {
+    type: "string",
+    value: expr.text
+  };
+  if (expr.kind === _typescript.SyntaxKind.FalseKeyword) return {
+    type: "boolean",
+    value: false
+  };
+  if (expr.kind === _typescript.SyntaxKind.TrueKeyword) return {
+    type: "boolean",
+    value: true
+  };
+  if (expr.kind === _typescript.SyntaxKind.NumericLiteral) return {
+    type: "number",
+    value: Number.parseFloat(expr.text)
+  };
+  if (expr.kind === _typescript.SyntaxKind.ObjectLiteralExpression) return {
+    type: "object",
+    value: parseObjectLiteral(expr, ctx)
+  };
+  throw new Error(`Unexpected property expression: "${expr.getText(ctx.sourceFile)}"`);
+}
+function parseObjectLiteral(arg, ctx) {
+  const result = {};
+  for (const p of arg.properties) {
+    if (!p.name || ![_typescript.SyntaxKind.Identifier, _typescript.SyntaxKind.StringLiteral].includes(p.name.kind)) throw new Error(`Unexpected property name: "${p.getText(ctx.sourceFile)}"`);
+    const nameNode = p.name;
+    const name = nameNode.text;
+    if (p.kind !== _typescript.SyntaxKind.PropertyAssignment) throw new Error(`Unexpected property value: "${p.getText(ctx.sourceFile)}"`);
+    const p2 = p;
+    const valueExpression = p2.initializer;
+    const value = parseLiteralNode(valueExpression, ctx)?.value;
+    result[name] = value;
+  }
+  return result;
+}
+function getClassDeclarations(sourceFile) {
+  const children = sourceFile.getChildren();
+  const syntaxListNode = children.find(c => c.kind === _typescript.SyntaxKind.SyntaxList);
+  const result = syntaxListNode?.getChildren().filter(c => [_typescript.SyntaxKind.ClassDeclaration, _typescript.SyntaxKind.TypeAliasDeclaration].includes(c.kind));
+  return result || [];
+}

package/integrations/node.d.ts

@@ -0,0 +1 @@
+export declare function parseSchema(typescriptFiles: Record<string, string>): Record<string, any>;

package/integrations/node.mjs

@@ -0,0 +1,168 @@
+import { ScriptTarget, SyntaxKind, createSourceFile } from "typescript";
+import _ from "lodash";
+import pluralize from "pluralize";
+export function parseSchema(typescriptFiles) {
+  const result = {};
+  const typesMap = {};
+  for (const key in typescriptFiles) {
+    const text = typescriptFiles[key];
+    const sourceFile = createSourceFile(`${key}.ts`, text, ScriptTarget.Latest);
+    const classDeclarations = getClassDeclarations(sourceFile);
+    for (const cd of classDeclarations) {
+      const nameNode = cd.name;
+      if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
+        throw new Error("Cannot detect class name");
+      const name = nameNode.text;
+      typesMap[name] = { name, node: cd, sourceFile };
+    }
+  }
+  for (const key in typesMap) {
+    const { node, sourceFile } = typesMap[key];
+    const parsedClass = parseType(node, { typesMap, sourceFile });
+    if (parsedClass.name !== key)
+      throw new Error(`File name must correspond to exported class name ("${key}", "${parsedClass.name}")`);
+    result[key] = parsedClass;
+  }
+  for (const key in result) {
+    const isExtendingType = result[key].isExtending;
+    if (!isExtendingType)
+      continue;
+    if (!result[isExtendingType])
+      throw new Error(`Unknown type: "${isExtendingType}"`);
+    result[key].fields = { ...result[isExtendingType].fields, ...result[key].fields };
+    result[key].decorators = { ...result[isExtendingType].decorators, ...result[key].decorators };
+    if (result[key].decorators.entity && !result[key].fields?.id) {
+      throw new Error(`Entity "${key}" must have an id`);
+    }
+  }
+  return result;
+}
+function parseType(typeDeclaration, ctx) {
+  const { modifiers } = typeDeclaration;
+  const nameNode = typeDeclaration.name;
+  if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
+    throw new Error("Cannot detect class name");
+  const name = nameNode.text;
+  const comment = typeDeclaration.jsDoc?.[0]?.comment;
+  const decoratorNodes = modifiers?.filter((x) => x.kind === SyntaxKind.Decorator) || [];
+  const decoratorsArray = decoratorNodes?.map((x) => parseDecorator(x, ctx));
+  const decorators = {};
+  for (const d of decoratorsArray) {
+    decorators[d.name] = d.args;
+  }
+  if (typeDeclaration.kind === SyntaxKind.ClassDeclaration) {
+    const classDeclaration = typeDeclaration;
+    const { members, heritageClauses } = classDeclaration;
+    const isExtendingExpr = heritageClauses?.[0]?.types?.[0]?.expression;
+    const isExtending = isExtendingExpr?.text;
+    for (const m of members) {
+      if (m.kind !== SyntaxKind.PropertyDeclaration) {
+        throw new Error(`Unexpected class member - only properties are allowed("${m.getText(ctx.sourceFile)}")`);
+      }
+    }
+    const fieldsArray = members.map((m) => parseClassMember(m, ctx));
+    const fields = {};
+    for (const f of fieldsArray) {
+      fields[f.name] = f;
+    }
+    const handle = _.lowerFirst(name);
+    const handlePlural = pluralize(handle);
+    return { name, handle, handlePlural, decorators, fields, isExtending, comment };
+  }
+  if (typeDeclaration.kind === SyntaxKind.TypeAliasDeclaration) {
+    const typeAliasDeclaration = typeDeclaration;
+    if (typeAliasDeclaration.type.kind !== SyntaxKind.UnionType)
+      throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}`);
+    const typeAliasValue = typeAliasDeclaration.type;
+    const enumValues = typeAliasValue.types.map((node) => {
+      if (node.kind !== SyntaxKind.LiteralType) {
+        throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}`);
+      }
+      const { literal } = node;
+      if (literal.kind !== SyntaxKind.StringLiteral)
+        throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}`);
+      return literal.text;
+    });
+    if (typeDeclaration)
+      return { name, decorators, enumValues, comment };
+  }
+  throw new Error(`Unexpected type kind - "${name}"`);
+}
+function parseClassMember(node, ctx) {
+  const supportedPrimitiveTypes = ["string", "number", "boolean"];
+  const name = node.name.getText(ctx.sourceFile);
+  const defaultValueDescription = parseLiteralNode(node.initializer, ctx);
+  const defaultValue = defaultValueDescription?.value;
+  const isRequired = !!node.exclamationToken || !!defaultValueDescription;
+  const comment = node.jsDoc?.[0]?.comment;
+  const type = node.type?.getText(ctx.sourceFile) ?? defaultValueDescription?.type;
+  if (!type)
+    throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
+  if (!supportedPrimitiveTypes.includes(type) && !ctx.typesMap[type])
+    throw new Error(`Unexpected property type: '${type}'`);
+  if (defaultValueDescription) {
+    if (supportedPrimitiveTypes.includes(type) && defaultValueDescription.type !== type) {
+      throw new Error(`Default value type is different from field type: '${type}'`);
+    }
+    const enumValues = ctx.typesMap[type]?.enumValues;
+    if (enumValues && enumValues.includes(defaultValue)) {
+      throw new Error(`Default value type is different from field type: '${type}'`);
+    }
+  }
+  return { type, defaultValue, name, isRequired, comment };
+}
+function parseDecorator(decoratorNode, ctx) {
+  const expr = decoratorNode.expression;
+  if (expr.kind !== SyntaxKind.CallExpression)
+    throw new Error(`Unexpected decorator format: "${expr.getText(ctx.sourceFile)}"`);
+  const nameNode = expr.expression;
+  if (nameNode.kind !== SyntaxKind.Identifier)
+    throw new Error(`Unexpected decorator format: "${nameNode.getText(ctx.sourceFile)}"`);
+  return { name: nameNode.text, args: parseDecoratorArguments(expr, ctx) };
+}
+function parseDecoratorArguments(expr, ctx) {
+  const args = expr.arguments;
+  if (args.length === 0)
+    return {};
+  if (args.length > 1)
+    throw new Error(`Too many arguments - one expected: "${expr.getText(ctx.sourceFile)}"`);
+  const arg = args[0];
+  return parseLiteralNode(arg, ctx)?.value ?? {};
+}
+function parseLiteralNode(expr, ctx) {
+  if (!expr)
+    return void 0;
+  if (expr.kind === SyntaxKind.StringLiteral)
+    return { type: "string", value: expr.text };
+  if (expr.kind === SyntaxKind.FalseKeyword)
+    return { type: "boolean", value: false };
+  if (expr.kind === SyntaxKind.TrueKeyword)
+    return { type: "boolean", value: true };
+  if (expr.kind === SyntaxKind.NumericLiteral)
+    return { type: "number", value: Number.parseFloat(expr.text) };
+  if (expr.kind === SyntaxKind.ObjectLiteralExpression)
+    return { type: "object", value: parseObjectLiteral(expr, ctx) };
+  throw new Error(`Unexpected property expression: "${expr.getText(ctx.sourceFile)}"`);
+}
+function parseObjectLiteral(arg, ctx) {
+  const result = {};
+  for (const p of arg.properties) {
+    if (!p.name || ![SyntaxKind.Identifier, SyntaxKind.StringLiteral].includes(p.name.kind))
+      throw new Error(`Unexpected property name: "${p.getText(ctx.sourceFile)}"`);
+    const nameNode = p.name;
+    const name = nameNode.text;
+    if (p.kind !== SyntaxKind.PropertyAssignment)
+      throw new Error(`Unexpected property value: "${p.getText(ctx.sourceFile)}"`);
+    const p2 = p;
+    const valueExpression = p2.initializer;
+    const value = parseLiteralNode(valueExpression, ctx)?.value;
+    result[name] = value;
+  }
+  return result;
+}
+function getClassDeclarations(sourceFile) {
+  const children = sourceFile.getChildren();
+  const syntaxListNode = children.find((c) => c.kind === SyntaxKind.SyntaxList);
+  const result = syntaxListNode?.getChildren().filter((c) => [SyntaxKind.ClassDeclaration, SyntaxKind.TypeAliasDeclaration].includes(c.kind));
+  return result || [];
+}

package/integrations/nuxtModule.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.radsDbNuxt = void 0;
+var _kit = require("@nuxt/kit");
+const radsDbNuxt = (0, _kit.defineNuxtModule)({
+  meta: {
+    name: "rads-db",
+    compatibility: {
+      nuxt: "^3.0.0"
+    }
+  },
+  defaults: {},
+  setup(options, nuxt) {
+    const {
+      resolve
+    } = (0, _kit.createResolver)(require('url').pathToFileURL(__filename).toString());
+    (0, _kit.addServerHandler)({
+      handler: resolve("./nuxtModuleHandler")
+    });
+  }
+});
+exports.radsDbNuxt = radsDbNuxt;

package/integrations/nuxtModule.d.ts

@@ -0,0 +1 @@
+export declare const radsDbNuxt: import("@nuxt/schema").NuxtModule<{}>;

package/integrations/nuxtModule.mjs

@@ -0,0 +1,16 @@
+import { addServerHandler, createResolver, defineNuxtModule } from "@nuxt/kit";
+export const radsDbNuxt = defineNuxtModule({
+  meta: {
+    name: "rads-db",
+    compatibility: {
+      nuxt: "^3.0.0"
+    }
+  },
+  defaults: {},
+  setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    addServerHandler({
+      handler: resolve("./nuxtModuleHandler")
+    });
+  }
+});

package/integrations/nuxtModuleHandler.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _h = require("h3");
+var _schemaGenerated = _interopRequireDefault(require("@@/schema.generated.json"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const routes = getRoutes(_schemaGenerated.default);
+var _default = (0, _h.defineEventHandler)(event => {
+  const path = event.path.split("?")[0];
+  const method = (0, _h.getMethod)(event);
+  const p = (0, _h.getRequestPath)(event);
+  const query = (0, _h.getQuery)(event);
+  const rp = (0, _h.getRouterParams)(event);
+  console.log(path, p, query, rp);
+  if (method === "POST") {}
+  if (path === `${prefix}tcUser`) {
+    console.log("tcUser!");
+    return {
+      id: "15"
+    };
+  }
+  if (path === `${prefix}tcUsers`) {
+    console.log("tcUsers!");
+    return [{
+      id: "15"
+    }];
+  }
+  console.log(_schemaGenerated.default);
+});
+module.exports = _default;
+function getRoutes(entities) {
+  const prefix2 = "/api/";
+  const routes2 = {};
+  for (const entityKey in entities) {}
+}

package/integrations/nuxtModuleHandler.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<{
+    id: string;
+} | {
+    id: string;
+}[] | undefined>;
+export default _default;

package/integrations/nuxtModuleHandler.mjs

@@ -0,0 +1,28 @@
+import { defineEventHandler, getMethod, getQuery, getRequestPath, getRouterParams } from "h3";
+import schema from "@@/schema.generated.json";
+const routes = getRoutes(schema);
+export default defineEventHandler((event) => {
+  const path = event.path.split("?")[0];
+  const method = getMethod(event);
+  const p = getRequestPath(event);
+  const query = getQuery(event);
+  const rp = getRouterParams(event);
+  console.log(path, p, query, rp);
+  if (method === "POST") {
+  }
+  if (path === `${prefix}tcUser`) {
+    console.log("tcUser!");
+    return { id: "15" };
+  }
+  if (path === `${prefix}tcUsers`) {
+    console.log("tcUsers!");
+    return [{ id: "15" }];
+  }
+  console.log(schema);
+});
+function getRoutes(entities) {
+  const prefix2 = "/api/";
+  const routes2 = {};
+  for (const entityKey in entities) {
+  }
+}

package/integrations/vite.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.radsDbVite = radsDbVite;
+var _promises = _interopRequireDefault(require("node:fs/promises"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _node = require("./node.cjs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function radsDbVite(options) {
+  let isDev = false;
+  return {
+    name: "rads-db",
+    config(config, env) {
+      isDev = env.mode === "development";
+    },
+    async configResolved(config) {
+      if (!isDev) return;
+      console.time("[rads-db] Schema generated in");
+      const entitiesDir = options?.entitiesDir || "./entities";
+      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;
+      }
+      const schema = (0, _node.parseSchema)(entities);
+      await _promises.default.writeFile("./schema.generated.json", JSON.stringify(schema, null, 2));
+      console.timeEnd("[rads-db] Schema generated in");
+    }
+  };
+}

package/integrations/vite.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite';
+interface Options {
+    entitiesDir?: string;
+}
+export declare function radsDbVite(options?: Options): Plugin;
+export {};

package/integrations/vite.mjs

@@ -0,0 +1,31 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parseSchema } from "./node.mjs";
+export function radsDbVite(options) {
+  let isDev = false;
+  return {
+    name: "rads-db",
+    config(config, env) {
+      isDev = env.mode === "development";
+    },
+    async configResolved(config) {
+      if (!isDev)
+        return;
+      console.time("[rads-db] Schema generated in");
+      const entitiesDir = options?.entitiesDir || "./entities";
+      const response = await fs.readdir(entitiesDir, { withFileTypes: true });
+      const entities = {};
+      for (const file of response) {
+        if (!file.isFile())
+          continue;
+        if (!file.name.endsWith(".ts"))
+          continue;
+        const text = await fs.readFile(path.resolve(entitiesDir, file.name), "utf-8");
+        entities[file.name.slice(0, -3)] = text;
+      }
+      const schema = parseSchema(entities);
+      await fs.writeFile("./schema.generated.json", JSON.stringify(schema, null, 2));
+      console.timeEnd("[rads-db] Schema generated in");
+    }
+  };
+}

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "rads-db",
   "files": [
-    "dist"
+    "dist",
+    "drivers",
+    "integrations"
   ],
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -23,7 +25,7 @@
       "require": "./integrations/*.cjs"
     }
   },
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "keywords": [],
   "author": "",