rads-db 0.1.24 → 0.1.25

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 const zod = require('zod');
 const _ = require('lodash');
+const uuid = require('uuid');
 const pluralize = require('pluralize');
 const cosmos = require('@azure/cosmos');
 const _radsDb = require('_rads-db');
@@ -573,66 +574,173 @@ function getWhereNameOperatorPair(whereKey) {
 
 const driverConstructors = { memory, restApi, azureCosmos };
 const drivers = {};
-function generateMethods(schema, validators, args) {
+const computedPresets = {
+  createdAt: ({ doc }) => {
+    return doc.createdAt || (/* @__PURE__ */ new Date()).toISOString();
+  },
+  updatedAt: () => {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  },
+  autoincrement: () => {
+    return 42;
+  },
+  uuid: ({ oldDoc }) => {
+    if (!oldDoc)
+      return uuid.v4();
+  }
+};
+function generateMethods(schema, validators, options) {
   const db = { _schema: schema };
+  const opts = { computed: {}, driver: { type: "memory" }, ...options };
   for (const key in schema) {
+    verifyComputedPresense(schema, opts.computed);
     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" });
+    const driverInstance = getDriverInstance(schema, key, opts.driver);
     db[handle] = {
-      get: async (args2, ctx) => {
-        args2 = args2 || {};
-        const result = await driverInstance.get(args2, ctx);
-        if (args2.include)
-          await handleInclude(schema, key, args2.include, [result]);
+      get: async (args, ctx) => {
+        args = args || {};
+        const result = await driverInstance.get(args, ctx);
+        if (args.include)
+          await handleInclude(schema, key, args.include, [result]);
+        await handleComputed(schema, key, opts, [result]);
         return result;
       },
-      getMany: async (args2, ctx) => {
-        args2 = args2 || {};
-        const result = await driverInstance.getMany(args2, ctx);
-        if (args2.include)
-          await handleInclude(schema, key, args2.include, result.nodes);
+      getMany: async (args, ctx) => {
+        args = args || {};
+        const result = await driverInstance.getMany(args, ctx);
+        if (args.include)
+          await handleInclude(schema, key, args.include, result.nodes);
+        await handleComputed(schema, key, opts, result.nodes);
         return result;
       },
-      getAll: async (args2, ctx) => {
-        args2 = args2 || {};
-        const result = await driverInstance.getAll(args2, ctx);
-        if (args2.include)
-          await handleInclude(schema, key, args2.include, result);
+      getAll: async (args, ctx) => {
+        args = args || {};
+        const result = await driverInstance.getAll(args, ctx);
+        if (args.include)
+          await handleInclude(schema, key, args.include, result);
+        await handleComputed(schema, key, opts, result);
         return result;
       },
-      put: async (item, ctx) => {
-        if (!item?.id)
+      put: async (doc, ctx) => {
+        if (!doc?.id)
           throw new Error("Id is required");
-        const existingItem = await driverInstance.get({ where: { id: item.id } });
-        if (existingItem)
-          item = merge(existingItem, item);
-        item = validators[key](item);
-        await driverInstance.put(item, ctx);
-        return item;
+        const oldDoc = await driverInstance.get({ where: { id: doc.id } });
+        if (oldDoc)
+          doc = merge(oldDoc, doc);
+        doc = validators[key](doc);
+        await handlePrecomputed(schema, key, opts, [{ doc, oldDoc }]);
+        await driverInstance.put(doc, ctx);
+        return doc;
       },
-      putMany: async (items, ctx) => {
-        const ids = items.map((i) => {
+      putMany: async (docs, ctx) => {
+        const ids = docs.map((i) => {
           if (!i?.id)
             throw new Error("Id is required");
           return i.id;
         });
-        const existingItems = await driverInstance.getAll({ where: { id_in: ids } });
-        const existingItemsById = ___default.keyBy(existingItems, "id");
-        const itemsToSave = items.map((item) => {
-          item = merge(existingItemsById[item.id], item);
-          return validators[key](item);
+        const oldDocs = await driverInstance.getAll({ where: { id_in: ids } });
+        const oldDocsById = ___default.keyBy(oldDocs, "id");
+        const docArgsToSave = docs.map((doc) => {
+          const oldDoc = oldDocsById[doc.id];
+          doc = merge(oldDoc, doc);
+          doc = validators[key](doc);
+          return { oldDoc, doc };
         });
-        await driverInstance.putMany(itemsToSave, ctx);
-        return itemsToSave;
+        await handlePrecomputed(schema, key, opts, docArgsToSave);
+        const docsToSave = docArgsToSave.map((x) => x.doc);
+        await driverInstance.putMany(docsToSave, ctx);
+        return docsToSave;
       }
     };
   }
   return db;
 }
+async function handlePrecomputed(schema, key, opts, docs) {
+  const { precomputedFields, nestedTypeFields, fields } = schema[key];
+  const computed = opts.computed;
+  for (const fieldName of precomputedFields || []) {
+    let handler = computed[key]?.[fieldName];
+    if (!handler) {
+      const preset = fields?.[fieldName].decorators?.precomputed?.preset;
+      handler = computedPresets[preset || ""];
+      if (!handler)
+        throw new Error(`Computed handler for ${key}.${fieldName} was not found`);
+    }
+    const precomputedResults = docs.map(async ({ doc, oldDoc }) => {
+      doc[fieldName] = await handler({ doc, oldDoc });
+    });
+    await Promise.all(precomputedResults);
+  }
+  for (const fieldName of nestedTypeFields || []) {
+    const promises = docs.map(({ doc }) => {
+      let subDoc = doc[fieldName];
+      if (!subDoc)
+        return void 0;
+      if (!___default.isArray(subDoc))
+        subDoc = [subDoc];
+      return handlePrecomputed(
+        schema,
+        fields[fieldName].type,
+        opts,
+        subDoc.map((doc2) => ({ doc: doc2 }))
+      );
+    });
+    await Promise.all(promises);
+  }
+}
+async function handleComputed(schema, key, opts, data) {
+  const { computedFields, nestedTypeFields, fields } = schema[key];
+  const computed = opts.computed;
+  for (const fieldName of computedFields || []) {
+    let handler = computed[key][fieldName];
+    if (!handler) {
+      const preset = fields?.[fieldName].decorators?.computed?.preset;
+      handler = computedPresets[preset || ""];
+      if (!handler)
+        throw new Error(`Computed handler for ${key}.${fieldName} was not found`);
+    }
+    const computedResults = data.map(async (doc) => {
+      doc[fieldName] = await handler({ doc });
+    });
+    await Promise.all(computedResults);
+  }
+  for (const fieldName of nestedTypeFields || []) {
+    const promises = data.map((doc) => {
+      let subDoc = doc[fieldName];
+      if (!subDoc)
+        return void 0;
+      if (!___default.isArray(subDoc))
+        subDoc = [subDoc];
+      return handleComputed(schema, fields[fieldName].type, opts, subDoc);
+    });
+    await Promise.all(promises);
+  }
+}
+function verifyComputedPresense(schema, computed) {
+  for (const typeName in schema) {
+    const { fields } = schema[typeName];
+    if (!fields)
+      continue;
+    for (const fieldName in fields) {
+      const c = fields[fieldName].decorators?.computed || fields[fieldName].decorators?.precomputed;
+      if (c) {
+        if (c.preset) {
+          if (!computedPresets[c.preset]) {
+            throw new Error(`Unknown preset: '${c.preset}'`);
+          }
+        } else if (!computed?.[typeName]?.[fieldName]) {
+          throw new Error(
+            `Computed definition missing for field ${typeName}.${fieldName}. You must provide it during "createRads()".`
+          );
+        }
+      }
+    }
+  }
+}
 async function handleInclude(schema, entityName, include, result) {
   if (!result || !result.length || !include)
     return;
@@ -645,22 +753,38 @@ async function handleInclude(schema, entityName, include, result) {
       throw new Error(`Cannot find entity ${typeName}`);
     const idsToGet = /* @__PURE__ */ new Set();
     for (const item of result) {
-      const id = item[fieldName]?.id;
-      if (!id)
+      if (!item)
+        continue;
+      const fieldValue = item[fieldName];
+      if (!fieldValue)
         continue;
-      idsToGet.add(id);
+      const fieldValues = ___default.isArray(fieldValue) ? fieldValue : [fieldValue];
+      for (const fv of fieldValues) {
+        const id = fv?.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)
+      if (!item)
         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;
+      const fieldValue = item[fieldName];
+      if (!fieldValue)
+        continue;
+      const fieldValues = ___default.isArray(fieldValue) ? fieldValue : [fieldValue];
+      for (const fv of fieldValues) {
+        const id = fv?.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}")`);
+        Object.assign(fv, relatedEntity);
+      }
     }
   });
   await Promise.all(downloadRelationsPromises);
@@ -703,7 +827,7 @@ function getDriverInstanceInner(schema, key, driver) {
     },
     async get(args, ctx) {
       args = { ...args, maxItemCount: 1 };
-      const result = (await driverInstance.getMany(args, ctx))?.nodes[0] || null;
+      const result = (await driverInstance.getMany(args, ctx))?.nodes[0];
       return result;
     },
     async put(data, ctx) {
@@ -712,7 +836,7 @@ function getDriverInstanceInner(schema, key, driver) {
       await driverInstance.putMany([data], ctx);
     },
     async clear() {
-      console.log("Not supported");
+      console.error(`"clear" not supported for driver "${driver.type}"`);
     },
     ...driverInstance
   };
@@ -726,6 +850,14 @@ function field(meta) {
   return function(a, b) {
   };
 }
+function precomputed(meta) {
+  return function(a, b) {
+  };
+}
+function computed(meta) {
+  return function(a, b) {
+  };
+}
 
 function createRads(args) {
   args = { ...args };
@@ -752,7 +884,9 @@ function getRestRoutes(db, prefix = "/") {
   return routes;
 }
 
+exports.computed = computed;
 exports.createRads = createRads;
 exports.entity = entity;
 exports.field = field;
 exports.getRestRoutes = getRestRoutes;
+exports.precomputed = precomputed;

package/dist/index.d.ts

@@ -60,12 +60,18 @@ interface CreateRadsArgs {
     driver?: DriverOptions;
     drivers?: Record<string, DriverOptions>;
     defaultDriver?: string;
+    computed?: Record<string, Record<string, Function>>;
+    context?: Record<string, any>;
 }
 type Schema = Record<string, TypeDefinition>;
 type SchemaValidators = Record<string, (item: any) => any>;
 interface TypeDefinition {
     name: string;
     decorators: Record<string, Record<string, any>>;
+    comment?: string;
+    precomputedFields?: string[];
+    computedFields?: string[];
+    nestedTypeFields?: string[];
     fields?: Record<string, FieldDefinition>;
     enumValues?: string[];
     handle?: string;
@@ -127,8 +133,10 @@ interface RadsRequestContext {
 
 declare function entity(meta?: EntityDecoratorArgs): (classConstructor: Function, _ctx?: ClassDecoratorContext<any>) => void;
 declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext) => void;
+declare function precomputed(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext) => void;
+declare function computed(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 { AzureCosmosDriverOptions, CreateRadsArgs, DeepPartial, Driver, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GenerateClientNormalizedOptions, GenerateClientOptions, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, MemoryDriverOptions, MinimalDriver, PutArgs, RadsRequestContext, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, createRads, entity, field, getRestRoutes };
+export { AzureCosmosDriverOptions, CreateRadsArgs, DeepPartial, Driver, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GenerateClientNormalizedOptions, GenerateClientOptions, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, MemoryDriverOptions, MinimalDriver, PutArgs, RadsRequestContext, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, computed, createRads, entity, field, getRestRoutes, precomputed };

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import _ from 'lodash';
+import { v4 } from 'uuid';
 import pluralize from 'pluralize';
 import { CosmosClient } from '@azure/cosmos';
 import { schema } from '_rads-db';
@@ -566,66 +567,173 @@ function getWhereNameOperatorPair(whereKey) {
 
 const driverConstructors = { memory, restApi, azureCosmos };
 const drivers = {};
-function generateMethods(schema, validators, args) {
+const computedPresets = {
+  createdAt: ({ doc }) => {
+    return doc.createdAt || (/* @__PURE__ */ new Date()).toISOString();
+  },
+  updatedAt: () => {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  },
+  autoincrement: () => {
+    return 42;
+  },
+  uuid: ({ oldDoc }) => {
+    if (!oldDoc)
+      return v4();
+  }
+};
+function generateMethods(schema, validators, options) {
   const db = { _schema: schema };
+  const opts = { computed: {}, driver: { type: "memory" }, ...options };
   for (const key in schema) {
+    verifyComputedPresense(schema, opts.computed);
     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" });
+    const driverInstance = getDriverInstance(schema, key, opts.driver);
     db[handle] = {
-      get: async (args2, ctx) => {
-        args2 = args2 || {};
-        const result = await driverInstance.get(args2, ctx);
-        if (args2.include)
-          await handleInclude(schema, key, args2.include, [result]);
+      get: async (args, ctx) => {
+        args = args || {};
+        const result = await driverInstance.get(args, ctx);
+        if (args.include)
+          await handleInclude(schema, key, args.include, [result]);
+        await handleComputed(schema, key, opts, [result]);
         return result;
       },
-      getMany: async (args2, ctx) => {
-        args2 = args2 || {};
-        const result = await driverInstance.getMany(args2, ctx);
-        if (args2.include)
-          await handleInclude(schema, key, args2.include, result.nodes);
+      getMany: async (args, ctx) => {
+        args = args || {};
+        const result = await driverInstance.getMany(args, ctx);
+        if (args.include)
+          await handleInclude(schema, key, args.include, result.nodes);
+        await handleComputed(schema, key, opts, result.nodes);
         return result;
       },
-      getAll: async (args2, ctx) => {
-        args2 = args2 || {};
-        const result = await driverInstance.getAll(args2, ctx);
-        if (args2.include)
-          await handleInclude(schema, key, args2.include, result);
+      getAll: async (args, ctx) => {
+        args = args || {};
+        const result = await driverInstance.getAll(args, ctx);
+        if (args.include)
+          await handleInclude(schema, key, args.include, result);
+        await handleComputed(schema, key, opts, result);
         return result;
       },
-      put: async (item, ctx) => {
-        if (!item?.id)
+      put: async (doc, ctx) => {
+        if (!doc?.id)
           throw new Error("Id is required");
-        const existingItem = await driverInstance.get({ where: { id: item.id } });
-        if (existingItem)
-          item = merge(existingItem, item);
-        item = validators[key](item);
-        await driverInstance.put(item, ctx);
-        return item;
+        const oldDoc = await driverInstance.get({ where: { id: doc.id } });
+        if (oldDoc)
+          doc = merge(oldDoc, doc);
+        doc = validators[key](doc);
+        await handlePrecomputed(schema, key, opts, [{ doc, oldDoc }]);
+        await driverInstance.put(doc, ctx);
+        return doc;
       },
-      putMany: async (items, ctx) => {
-        const ids = items.map((i) => {
+      putMany: async (docs, ctx) => {
+        const ids = docs.map((i) => {
           if (!i?.id)
             throw new Error("Id is required");
           return i.id;
         });
-        const existingItems = await driverInstance.getAll({ where: { id_in: ids } });
-        const existingItemsById = _.keyBy(existingItems, "id");
-        const itemsToSave = items.map((item) => {
-          item = merge(existingItemsById[item.id], item);
-          return validators[key](item);
+        const oldDocs = await driverInstance.getAll({ where: { id_in: ids } });
+        const oldDocsById = _.keyBy(oldDocs, "id");
+        const docArgsToSave = docs.map((doc) => {
+          const oldDoc = oldDocsById[doc.id];
+          doc = merge(oldDoc, doc);
+          doc = validators[key](doc);
+          return { oldDoc, doc };
         });
-        await driverInstance.putMany(itemsToSave, ctx);
-        return itemsToSave;
+        await handlePrecomputed(schema, key, opts, docArgsToSave);
+        const docsToSave = docArgsToSave.map((x) => x.doc);
+        await driverInstance.putMany(docsToSave, ctx);
+        return docsToSave;
       }
     };
   }
   return db;
 }
+async function handlePrecomputed(schema, key, opts, docs) {
+  const { precomputedFields, nestedTypeFields, fields } = schema[key];
+  const computed = opts.computed;
+  for (const fieldName of precomputedFields || []) {
+    let handler = computed[key]?.[fieldName];
+    if (!handler) {
+      const preset = fields?.[fieldName].decorators?.precomputed?.preset;
+      handler = computedPresets[preset || ""];
+      if (!handler)
+        throw new Error(`Computed handler for ${key}.${fieldName} was not found`);
+    }
+    const precomputedResults = docs.map(async ({ doc, oldDoc }) => {
+      doc[fieldName] = await handler({ doc, oldDoc });
+    });
+    await Promise.all(precomputedResults);
+  }
+  for (const fieldName of nestedTypeFields || []) {
+    const promises = docs.map(({ doc }) => {
+      let subDoc = doc[fieldName];
+      if (!subDoc)
+        return void 0;
+      if (!_.isArray(subDoc))
+        subDoc = [subDoc];
+      return handlePrecomputed(
+        schema,
+        fields[fieldName].type,
+        opts,
+        subDoc.map((doc2) => ({ doc: doc2 }))
+      );
+    });
+    await Promise.all(promises);
+  }
+}
+async function handleComputed(schema, key, opts, data) {
+  const { computedFields, nestedTypeFields, fields } = schema[key];
+  const computed = opts.computed;
+  for (const fieldName of computedFields || []) {
+    let handler = computed[key][fieldName];
+    if (!handler) {
+      const preset = fields?.[fieldName].decorators?.computed?.preset;
+      handler = computedPresets[preset || ""];
+      if (!handler)
+        throw new Error(`Computed handler for ${key}.${fieldName} was not found`);
+    }
+    const computedResults = data.map(async (doc) => {
+      doc[fieldName] = await handler({ doc });
+    });
+    await Promise.all(computedResults);
+  }
+  for (const fieldName of nestedTypeFields || []) {
+    const promises = data.map((doc) => {
+      let subDoc = doc[fieldName];
+      if (!subDoc)
+        return void 0;
+      if (!_.isArray(subDoc))
+        subDoc = [subDoc];
+      return handleComputed(schema, fields[fieldName].type, opts, subDoc);
+    });
+    await Promise.all(promises);
+  }
+}
+function verifyComputedPresense(schema, computed) {
+  for (const typeName in schema) {
+    const { fields } = schema[typeName];
+    if (!fields)
+      continue;
+    for (const fieldName in fields) {
+      const c = fields[fieldName].decorators?.computed || fields[fieldName].decorators?.precomputed;
+      if (c) {
+        if (c.preset) {
+          if (!computedPresets[c.preset]) {
+            throw new Error(`Unknown preset: '${c.preset}'`);
+          }
+        } else if (!computed?.[typeName]?.[fieldName]) {
+          throw new Error(
+            `Computed definition missing for field ${typeName}.${fieldName}. You must provide it during "createRads()".`
+          );
+        }
+      }
+    }
+  }
+}
 async function handleInclude(schema, entityName, include, result) {
   if (!result || !result.length || !include)
     return;
@@ -638,22 +746,38 @@ async function handleInclude(schema, entityName, include, result) {
       throw new Error(`Cannot find entity ${typeName}`);
     const idsToGet = /* @__PURE__ */ new Set();
     for (const item of result) {
-      const id = item[fieldName]?.id;
-      if (!id)
+      if (!item)
+        continue;
+      const fieldValue = item[fieldName];
+      if (!fieldValue)
         continue;
-      idsToGet.add(id);
+      const fieldValues = _.isArray(fieldValue) ? fieldValue : [fieldValue];
+      for (const fv of fieldValues) {
+        const id = fv?.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)
+      if (!item)
         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;
+      const fieldValue = item[fieldName];
+      if (!fieldValue)
+        continue;
+      const fieldValues = _.isArray(fieldValue) ? fieldValue : [fieldValue];
+      for (const fv of fieldValues) {
+        const id = fv?.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}")`);
+        Object.assign(fv, relatedEntity);
+      }
     }
   });
   await Promise.all(downloadRelationsPromises);
@@ -696,7 +820,7 @@ function getDriverInstanceInner(schema, key, driver) {
     },
     async get(args, ctx) {
       args = { ...args, maxItemCount: 1 };
-      const result = (await driverInstance.getMany(args, ctx))?.nodes[0] || null;
+      const result = (await driverInstance.getMany(args, ctx))?.nodes[0];
       return result;
     },
     async put(data, ctx) {
@@ -705,7 +829,7 @@ function getDriverInstanceInner(schema, key, driver) {
       await driverInstance.putMany([data], ctx);
     },
     async clear() {
-      console.log("Not supported");
+      console.error(`"clear" not supported for driver "${driver.type}"`);
     },
     ...driverInstance
   };
@@ -719,6 +843,14 @@ function field(meta) {
   return function(a, b) {
   };
 }
+function precomputed(meta) {
+  return function(a, b) {
+  };
+}
+function computed(meta) {
+  return function(a, b) {
+  };
+}
 
 function createRads(args) {
   args = { ...args };
@@ -745,4 +877,4 @@ function getRestRoutes(db, prefix = "/") {
   return routes;
 }
 
-export { createRads, entity, field, getRestRoutes };
+export { computed, createRads, entity, field, getRestRoutes, precomputed };

package/integrations/lib.cjs

@@ -60,6 +60,17 @@ function parseSchema(typescriptFiles) {
       throw new Error(`Entity "${key}" must have an id`);
     }
   }
+  for (const key in result) {
+    const type = result[key];
+    const fields = type.fields;
+    if (!fields) continue;
+    const precomputedFields = _lodash.default.values(fields).filter(f => !!f.decorators?.precomputed).map(f => f.name);
+    const computedFields = _lodash.default.values(fields).filter(f => !!f.decorators?.computed).map(f => f.name);
+    const nestedTypeFields = _lodash.default.values(fields).filter(f => result[f.type] && result[f.type].fields && !result[f.type].decorators.entity).map(f => f.name);
+    if (precomputedFields.length) type.precomputedFields = precomputedFields;
+    if (computedFields.length) type.computedFields = computedFields;
+    if (nestedTypeFields.length) type.nestedTypeFields = nestedTypeFields;
+  }
   return result;
 }
 function parseType(typeDeclaration, typeName, ctx) {
@@ -70,12 +81,7 @@ function parseType(typeDeclaration, typeName, ctx) {
   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;
-  }
+  const decorators = parseDecorators(modifiers, ctx);
   if (typeDeclaration.kind === _typescript.SyntaxKind.ClassDeclaration) {
     const classDeclaration = typeDeclaration;
     const {
@@ -96,7 +102,7 @@ function parseType(typeDeclaration, typeName, ctx) {
     }
     const handle = _lodash.default.lowerFirst(name);
     const handlePlural = (0, _pluralize.default)(handle);
-    return {
+    const result = {
       name,
       handle,
       handlePlural,
@@ -105,10 +111,11 @@ function parseType(typeDeclaration, typeName, ctx) {
       isExtending,
       comment
     };
+    return result;
   }
   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)}`);
+    if (typeAliasDeclaration.type.kind !== _typescript.SyntaxKind.UnionType) throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
     const typeAliasValue = typeAliasDeclaration.type;
     const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
     if (typeDeclaration) return {
@@ -120,6 +127,16 @@ function parseType(typeDeclaration, typeName, ctx) {
   }
   throw new Error(`Unexpected type kind - "${name}"`);
 }
+function parseDecorators(modifiers, ctx) {
+  if (!modifiers) return {};
+  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;
+  }
+  return decorators;
+}
 function getEnumValues(node, parentNode, ctx) {
   return node.types.map(node2 => {
     if (node2.kind !== _typescript.SyntaxKind.LiteralType) {
@@ -138,11 +155,12 @@ function parseClassMember(node, parentName, ctx) {
   const defaultValue = defaultValueDescription?.value;
   const isRequired = !node.questionToken;
   const comment = node.jsDoc?.[0]?.comment;
+  const decorators = parseDecorators(node.modifiers, ctx);
   const {
     isArray,
     type
   } = parseFieldType(ctx, parentName, name, node, defaultValueDescription);
-  return {
+  const result = {
     type,
     defaultValue,
     name,
@@ -150,6 +168,8 @@ function parseClassMember(node, parentName, ctx) {
     isArray,
     comment
   };
+  if (!_lodash.default.isEmpty(decorators)) result.decorators = decorators;
+  return result;
 }
 function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
   const supportedPrimitiveTypes = ["string", "number", "boolean"];

package/integrations/lib.mjs

@@ -40,6 +40,21 @@ export function parseSchema(typescriptFiles) {
       throw new Error(`Entity "${key}" must have an id`);
     }
   }
+  for (const key in result) {
+    const type = result[key];
+    const fields = type.fields;
+    if (!fields)
+      continue;
+    const precomputedFields = _.values(fields).filter((f) => !!f.decorators?.precomputed).map((f) => f.name);
+    const computedFields = _.values(fields).filter((f) => !!f.decorators?.computed).map((f) => f.name);
+    const nestedTypeFields = _.values(fields).filter((f) => result[f.type] && result[f.type].fields && !result[f.type].decorators.entity).map((f) => f.name);
+    if (precomputedFields.length)
+      type.precomputedFields = precomputedFields;
+    if (computedFields.length)
+      type.computedFields = computedFields;
+    if (nestedTypeFields.length)
+      type.nestedTypeFields = nestedTypeFields;
+  }
   return result;
 }
 function parseType(typeDeclaration, typeName, ctx) {
@@ -49,12 +64,7 @@ function parseType(typeDeclaration, typeName, ctx) {
     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;
-  }
+  const decorators = parseDecorators(modifiers, ctx);
   if (typeDeclaration.kind === SyntaxKind.ClassDeclaration) {
     const classDeclaration = typeDeclaration;
     const { members, heritageClauses } = classDeclaration;
@@ -72,12 +82,21 @@ function parseType(typeDeclaration, typeName, ctx) {
     }
     const handle = _.lowerFirst(name);
     const handlePlural = pluralize(handle);
-    return { name, handle, handlePlural, decorators, fields, isExtending, comment };
+    const result = {
+      name,
+      handle,
+      handlePlural,
+      decorators,
+      fields,
+      isExtending,
+      comment
+    };
+    return result;
   }
   if (typeDeclaration.kind === SyntaxKind.TypeAliasDeclaration) {
     const typeAliasDeclaration = typeDeclaration;
     if (typeAliasDeclaration.type.kind !== SyntaxKind.UnionType)
-      throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}`);
+      throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
     const typeAliasValue = typeAliasDeclaration.type;
     const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
     if (typeDeclaration)
@@ -85,6 +104,17 @@ function parseType(typeDeclaration, typeName, ctx) {
   }
   throw new Error(`Unexpected type kind - "${name}"`);
 }
+function parseDecorators(modifiers, ctx) {
+  if (!modifiers)
+    return {};
+  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;
+  }
+  return decorators;
+}
 function getEnumValues(node, parentNode, ctx) {
   return node.types.map((node2) => {
     if (node2.kind !== SyntaxKind.LiteralType) {
@@ -102,8 +132,12 @@ function parseClassMember(node, parentName, ctx) {
   const defaultValue = defaultValueDescription?.value;
   const isRequired = !node.questionToken;
   const comment = node.jsDoc?.[0]?.comment;
+  const decorators = parseDecorators(node.modifiers, ctx);
   const { isArray, type } = parseFieldType(ctx, parentName, name, node, defaultValueDescription);
-  return { type, defaultValue, name, isRequired, isArray, comment };
+  const result = { type, defaultValue, name, isRequired, isArray, comment };
+  if (!_.isEmpty(decorators))
+    result.decorators = decorators;
+  return result;
 }
 function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
   const supportedPrimitiveTypes = ["string", "number", "boolean"];

package/package.json

@@ -28,7 +28,7 @@
       "require": "./integrations/*.cjs"
     }
   },
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "keywords": [],
   "author": "",
@@ -59,14 +59,16 @@
     "tsup": "^6.7.0",
     "unbuild": "^1.2.1",
     "vite": "^4.0.0",
-    "vitest": "^0.31.0"
+    "vitest": "^0.31.0",
+    "@types/lodash": "4.14.191",
+    "@types/uuid": "^9.0.2"
   },
   "dependencies": {
     "@nuxt/kit": "^3.5.1",
-    "@types/lodash": "4.14.191",
     "dataloader": "^2.2.2",
     "lodash": "^4.17.21",
     "pluralize": "^8.0.0",
+    "uuid": ">=8",
     "zod": "^3.21.4"
   },
   "scripts": {