rads-db 0.1.34 → 0.1.36

package/README.md

@@ -1,4 +1,11 @@
-# Introduction
+## Contributing guide
+
+1. Clone project
+2. `pnpm dev`
+3. Add tests
+4. Fix tests
+
+## Introduction
 
 When you work with the databases
 

package/dist/index.cjs

@@ -46,8 +46,11 @@ function getZodSchema(zodSchemas, schema, key) {
   }
   const objectSchema = {};
   for (const fieldName in type.fields) {
-    const shouldBeLazy = type.fields[fieldName].type === type.name;
     const f = type.fields[fieldName];
+    if (f.decorators?.computed || f.decorators?.precomputed) {
+      continue;
+    }
+    const shouldBeLazy = f.type === type.name;
     objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, f, shouldBeLazy);
   }
   return zod.z.object(objectSchema);
@@ -83,7 +86,7 @@ function getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy) {
   if (schema[field.type]) {
     const getSchema = () => {
       let zodSchema = getZodSchema(zodSchemas, schema, field.type);
-      if (schema[field.type].decorators.entity) {
+      if (field.isRelation) {
         zodSchema = zodSchema.deepPartial().required({ id: true });
       }
       return zodSchema;
@@ -305,7 +308,7 @@ const computedPresets = {
   }
 };
 async function handlePrecomputed(ctx, docs) {
-  const { schema, typeName, options, drivers } = ctx;
+  const { schema, typeName, options, drivers, db } = ctx;
   if (drivers[typeName]?.driverName === "restApi")
     return;
   const { precomputedFields, nestedTypeFields, fields } = schema[typeName];
@@ -319,12 +322,12 @@ async function handlePrecomputed(ctx, docs) {
         throw new Error(`Computed handler for ${typeName}.${fieldName} was not found`);
     }
     const precomputedResults = docs.map(async ({ doc, oldDoc }) => {
-      doc[fieldName] = await handler({ doc, oldDoc });
+      doc[fieldName] = await handler({ doc, oldDoc, db });
     });
     await Promise.all(precomputedResults);
   }
   for (const fieldName of nestedTypeFields || []) {
-    const promises = docs.map(({ doc }) => {
+    const promises = docs.map(({ doc, db: db2 }) => {
       let subDoc = doc[fieldName];
       if (!subDoc)
         return void 0;
@@ -338,19 +341,20 @@ async function handlePrecomputed(ctx, docs) {
     await Promise.all(promises);
   }
 }
-async function handleComputed(schema, key, opts, data) {
-  const { computedFields, nestedTypeFields, fields } = schema[key];
-  const computed = opts.computed;
+async function handleComputed(ctx, data) {
+  const { schema, typeName, options, db } = ctx;
+  const { computedFields, nestedTypeFields, fields } = schema[typeName];
+  const computed = options.computed;
   for (const fieldName of computedFields || []) {
-    let handler = computed[key][fieldName];
+    let handler = computed[typeName][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`);
+        throw new Error(`Computed handler for ${typeName}.${fieldName} was not found`);
     }
     const computedResults = data.map(async (doc) => {
-      doc[fieldName] = await handler({ doc });
+      doc[fieldName] = await handler({ doc, db });
     });
     await Promise.all(computedResults);
   }
@@ -361,7 +365,7 @@ async function handleComputed(schema, key, opts, data) {
         return void 0;
       if (!___default.isArray(subDoc))
         subDoc = [subDoc];
-      return handleComputed(schema, fields[fieldName].type, opts, subDoc);
+      return handleComputed({ ...ctx, typeName: fields[fieldName].type }, subDoc);
     });
     await Promise.all(promises);
   }
@@ -387,6 +391,16 @@ function verifyComputedPresense(schema, computed, effects) {
     }
   }
 }
+async function handleEffectsBeforePut(ctx, docs) {
+  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
+    return [];
+  return Promise.all(ctx.effects[ctx.typeName].map((ef) => ef.beforePut?.(ctx, docs)));
+}
+async function handleEffectsAfterPut(ctx, docs, beforePutResults) {
+  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
+    return [];
+  return Promise.all(ctx.effects[ctx.typeName].map((ef, i) => ef.afterPut(ctx, docs, beforePutResults[i])));
+}
 
 function diff(object, base, includeDenormFields = false) {
   if (!base)
@@ -498,34 +512,105 @@ function validateEventSourcingSetup(schema, entityName, eventEntityName, aggrega
     }
   }
 }
-async function handleEffectsBeforePut(ctx, docs) {
-  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
-    return [];
-  return Promise.all(ctx.effects[ctx.typeName].map((ef) => ef.beforePut?.(ctx, docs)));
+
+function verifyRelationsSetup(schema, effects) {
+  for (const entityName in schema) {
+    const entity = schema[entityName];
+    for (const fName in entity.fields) {
+      const f = entity.fields[fName];
+      const denormFields = f.relationDenormFields;
+      if (!f.isRelation || !denormFields)
+        continue;
+      effects[f.type].push({
+        async afterPut(ctx, docs, beforePutResult) {
+          const { drivers } = ctx;
+          const changedDocs = docs.filter((d) => denormFields.some((f2) => !___default.isEqual(d.doc[f2], d.oldDoc?.[f2])));
+          if (!changedDocs.length)
+            return;
+          const changedDocsById = ___default.keyBy(changedDocs, "doc.id");
+          const id_in = ___default.keys(changedDocsById);
+          if (!id_in.length)
+            return;
+          const affectedDocs = await drivers[entityName].getAll({
+            where: { [fName]: { id_in } },
+            maxItemCount: 1e3
+          });
+          if (!affectedDocs.length)
+            return;
+          for (const d of affectedDocs) {
+            const cd = changedDocsById[d[fName]?.id].doc;
+            if (!cd) {
+              console.warn(
+                `Error when updating denorm fields for ${entityName}.${fName}: cannot find updated ${f.type}#${d[fName]?.id}`
+              );
+              continue;
+            }
+            d[fName] = ___default.pick(cd, ["id", ...denormFields]);
+          }
+          await drivers[entityName].putMany(affectedDocs);
+        }
+      });
+    }
+  }
 }
-async function handleEffectsAfterPut(ctx, docs, beforePutResults) {
-  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
-    return [];
-  return Promise.all(ctx.effects[ctx.typeName].map((ef, i) => ef.afterPut(ctx, docs, beforePutResults[i])));
+async function fillDenormFieldsBeforePut(computedContext, docUpdates) {
+  const { schema, typeName, drivers } = computedContext;
+  const fields = schema[typeName].fields || {};
+  const relationsToInclude = ___default.values(fields).filter((f) => f.isRelation && f.relationDenormFields);
+  const docs = docUpdates.map((d) => d.doc);
+  const promises = relationsToInclude.map(async (f) => {
+    const docsWithRelation = docs.filter((d) => d[f.name]?.id);
+    const docsByRelationId = ___default.keyBy(docsWithRelation, `${f.name}.id`);
+    const id_in = ___default.keys(docsByRelationId);
+    if (!id_in)
+      return;
+    const driverInstance = drivers[f.type];
+    const relatedDocs = await driverInstance.getAll({ where: { id_in } });
+    const relatedDocsById = ___default.keyBy(relatedDocs, "id");
+    for (const d of docsWithRelation) {
+      const relatedDoc = relatedDocsById[d[f.name].id];
+      if (!relatedDoc) {
+        console.warn(`Relation ${f.type}#${d[f.name].id} not found for ${typeName}.${f.name}. Skipping...`);
+      }
+      d[f.name] = ___default.pick(relatedDoc, [...f.relationDenormFields, "id"]);
+    }
+  });
+  await Promise.all(promises);
 }
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
-  const db = { _schema: schema };
   const opts = { computed: {}, driver: memory(), ...options };
+  const db = {
+    _schema: schema,
+    uploadFile(args) {
+      if (!opts.fileUploadDriver)
+        throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
+      return opts.fileUploadDriver.uploadFile(args);
+    }
+  };
   const effects = {};
   for (const key in schema) {
     effects[key] = [];
   }
   verifyComputedPresense(schema, opts.computed);
   verifyEventSourcingSetup(schema, effects);
+  verifyRelationsSetup(schema, effects);
   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 computedContext = { schema, typeName: key, validators, options: opts, drivers, effects };
+    const computedContext = {
+      schema,
+      typeName: key,
+      validators,
+      options: opts,
+      drivers,
+      effects,
+      db
+    };
     const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
     db[handle] = {
       getAgg: async (args, ctx) => {
@@ -540,7 +625,7 @@ function generateMethods(schema, validators, options) {
         if (result && args.include)
           await handleInclude(computedContext, args.include, [result]);
         if (result)
-          await handleComputed(schema, key, opts, [result]);
+          await handleComputed(computedContext, [result]);
         return result;
       },
       getMany: async (args, ctx) => {
@@ -548,7 +633,7 @@ function generateMethods(schema, validators, options) {
         const result = await driverInstance.getMany(args, ctx);
         if (args.include)
           await handleInclude(computedContext, args.include, result.nodes);
-        await handleComputed(schema, key, opts, result.nodes);
+        await handleComputed(computedContext, result.nodes);
         return result;
       },
       getAll: async (args, ctx) => {
@@ -556,7 +641,7 @@ function generateMethods(schema, validators, options) {
         const result = await driverInstance.getAll(args, ctx);
         if (args.include)
           await handleInclude(computedContext, args.include, result);
-        await handleComputed(schema, key, opts, result);
+        await handleComputed(computedContext, result);
         return result;
       },
       put: async (doc, ctx) => {
@@ -568,10 +653,12 @@ function generateMethods(schema, validators, options) {
         if (oldDoc)
           doc = merge(oldDoc, doc);
         doc = validators[key](doc);
-        await handlePrecomputed(computedContext, [{ doc, oldDoc }]);
-        const beforePutResults = await handleEffectsBeforePut(computedContext, [{ doc, oldDoc }]);
+        const docArgsToSave = [{ doc, oldDoc }];
+        await fillDenormFieldsBeforePut(computedContext, docArgsToSave);
+        await handlePrecomputed(computedContext, docArgsToSave);
+        const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave);
         await driverInstance.put(doc, ctx);
-        await handleEffectsAfterPut(computedContext, [{ doc, oldDoc }], beforePutResults);
+        await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults);
         return doc;
       },
       putMany: async (docs, ctx) => {
@@ -590,6 +677,7 @@ function generateMethods(schema, validators, options) {
           doc = validators[key](doc);
           return { oldDoc, doc };
         });
+        await fillDenormFieldsBeforePut(computedContext, docArgsToSave);
         await handlePrecomputed(computedContext, docArgsToSave);
         const docsToSave = docArgsToSave.map((x) => x.doc);
         const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave);
@@ -606,7 +694,7 @@ async function handleInclude(computedContext, include, result) {
     return;
   const { schema, typeName, drivers } = computedContext;
   const fields = schema[typeName].fields || {};
-  const relationsToInclude = ___default.keys(include).filter((key) => include[key] && schema[fields[key].type].decorators.entity);
+  const relationsToInclude = ___default.keys(include).filter((key) => include[key] && fields[key].isRelation);
   const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
     const typeName2 = fields[fieldName].type;
     const type = schema[typeName2];

package/dist/index.d.ts

@@ -26,7 +26,7 @@ type GetAggArgsAny = GetAggArgs<any, any>;
 type GetArgsInclude<E, EN extends keyof EntityMeta, R extends keyof E = keyof EntityMeta[EN]['relations'] & keyof E> = [R] extends [never] ? Record<string, never> : {
     _pick?: EntityMeta[EN]['primitives'][];
 } & {
-    [K in R]?: GetArgsInclude<NonNullable<E[K]>, EntityMeta[EN]['relations'][K]>;
+    [K in R]?: GetArgsInclude<NonNullable<E[K]>, EntityMeta[EN]['relations'][K]['entityName']>;
 };
 type GetAggResponse<EN extends keyof EntityMeta, A extends GetAggArgs<EN, any>> = {
     [K in A['agg'][0]]: K extends '_count' ? number : number | undefined;
@@ -41,16 +41,19 @@ type GetResponse<E, EN extends keyof EntityMeta, A extends GetArgs<E, EN, any>>
 type GetResponseInclude<E, EN extends keyof EntityMeta, I extends GetArgsInclude<E, EN>> = I extends {
     _pick: string[];
 } ? GetResponseIncludeSelect<E, I> : {
-    [K in keyof E]: K extends keyof EntityMeta[EN]['relations'] ? K extends keyof I ? GetResponseInclude<E[K], EntityMeta[EN]['relations'][K], I[K]> : Pick<E[K], 'id'> : E[K];
+    [K in keyof E]: K extends keyof EntityMeta[EN]['relations'] ? K extends keyof I ? GetResponseInclude<EntityMeta[EN]['relations'][K]['entity'], EntityMeta[EN]['relations'][K]['entityName'], I[K]> : Pick<EntityMeta[EN]['relations'][K]['entity'], EntityMeta[EN]['relations'][K]['denormFields']> : E[K];
 };
 interface GetResponseIncludeSelect<E, I> {
 }
 type GetResponseNoInclude<E, EN extends keyof EntityMeta> = {
-    [K in keyof E]: K extends keyof EntityMeta[EN]['relations'] ? Pick<E[K], 'id'> : E[K];
+    [K in keyof E]: K extends keyof EntityMeta[EN]['relations'] ? Pick<EntityMeta[EN]['relations'][K]['entity'], EntityMeta[EN]['relations'][K]['denormFields']> : E[K];
 };
 type DeepPartial<T> = {
     [K in keyof T]?: DeepPartial<T[K]>;
 };
+type Relation<T extends {
+    id: any;
+}, K extends Exclude<keyof T, 'id'> = never> = Pick<T, K | 'id'> & DeepPartial<T>;
 type PutArgs<T> = {
     id: string;
 } & DeepPartial<T>;
@@ -114,6 +117,7 @@ interface CreateRadsArgs {
     schema?: Schema;
     driver?: DriverConstructor;
     drivers?: Record<string, DriverConstructor>;
+    fileUploadDriver?: FileUploadDriver;
     computed?: Record<string, Record<string, Function>>;
     context?: Record<string, any>;
 }
@@ -131,6 +135,16 @@ interface TypeDefinition {
     handle?: string;
     handlePlural?: string;
 }
+interface FileUploadDriver {
+    driverName: string;
+    uploadFile(args: FileUploadArgs): Promise<string>;
+}
+interface FileUploadArgs {
+    blob: Blob;
+    containerName?: string;
+    fileName?: string;
+    options: any;
+}
 interface MinimalDriver {
     driverName: string;
     putMany: (item: Record<string, any>[], ctx?: RadsRequestContext) => MaybePromise<void>;
@@ -152,10 +166,13 @@ interface FieldDefinition {
     defaultValueCopyFrom?: string;
     isRequired?: boolean;
     isArray?: boolean;
+    isRelation?: boolean;
+    relationDenormFields?: string[];
     comment?: string;
     decorators?: Record<string, Record<string, any>>;
 }
 interface ComputedContext {
+    db: RadsDb;
     schema: Schema;
     typeName: string;
     validators: SchemaValidators;
@@ -184,6 +201,13 @@ interface RestDriverOptions {
 }
 interface MemoryDriverOptions {
 }
+interface MemoryFileUploadDriverOptions {
+}
+interface AzureStorageBlobUploadDriverOptions {
+    connectionString: string;
+    defaultContainer?: string;
+    fileNamePrefix?: string;
+}
 interface AzureCosmosDriverOptions {
     endpoint: string;
     accountKey?: string;
@@ -211,4 +235,4 @@ declare function computed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassField
 declare function createRads(args?: CreateRadsArgs): RadsDb;
 declare function getRestRoutes(db: RadsDb, prefix?: string): Record<string, Record<string, Function>>;
 
-export { AzureCosmosDriverOptions, Change, ComputedContext, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, Driver, DriverConstructor, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, MemoryDriverOptions, MinimalDriver, PutArgs, PutEffect, RadsRequestContext, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, computed, createRads, entity, field, getRestRoutes, precomputed, ui };
+export { AzureCosmosDriverOptions, AzureStorageBlobUploadDriverOptions, Change, ComputedContext, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, Driver, DriverConstructor, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, MemoryDriverOptions, MemoryFileUploadDriverOptions, MinimalDriver, PutArgs, PutEffect, RadsRequestContext, Relation, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, computed, createRads, entity, field, getRestRoutes, precomputed, ui };

package/dist/index.mjs

@@ -40,8 +40,11 @@ function getZodSchema(zodSchemas, schema, key) {
   }
   const objectSchema = {};
   for (const fieldName in type.fields) {
-    const shouldBeLazy = type.fields[fieldName].type === type.name;
     const f = type.fields[fieldName];
+    if (f.decorators?.computed || f.decorators?.precomputed) {
+      continue;
+    }
+    const shouldBeLazy = f.type === type.name;
     objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, f, shouldBeLazy);
   }
   return z.object(objectSchema);
@@ -77,7 +80,7 @@ function getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy) {
   if (schema[field.type]) {
     const getSchema = () => {
       let zodSchema = getZodSchema(zodSchemas, schema, field.type);
-      if (schema[field.type].decorators.entity) {
+      if (field.isRelation) {
         zodSchema = zodSchema.deepPartial().required({ id: true });
       }
       return zodSchema;
@@ -299,7 +302,7 @@ const computedPresets = {
   }
 };
 async function handlePrecomputed(ctx, docs) {
-  const { schema, typeName, options, drivers } = ctx;
+  const { schema, typeName, options, drivers, db } = ctx;
   if (drivers[typeName]?.driverName === "restApi")
     return;
   const { precomputedFields, nestedTypeFields, fields } = schema[typeName];
@@ -313,12 +316,12 @@ async function handlePrecomputed(ctx, docs) {
         throw new Error(`Computed handler for ${typeName}.${fieldName} was not found`);
     }
     const precomputedResults = docs.map(async ({ doc, oldDoc }) => {
-      doc[fieldName] = await handler({ doc, oldDoc });
+      doc[fieldName] = await handler({ doc, oldDoc, db });
     });
     await Promise.all(precomputedResults);
   }
   for (const fieldName of nestedTypeFields || []) {
-    const promises = docs.map(({ doc }) => {
+    const promises = docs.map(({ doc, db: db2 }) => {
       let subDoc = doc[fieldName];
       if (!subDoc)
         return void 0;
@@ -332,19 +335,20 @@ async function handlePrecomputed(ctx, docs) {
     await Promise.all(promises);
   }
 }
-async function handleComputed(schema, key, opts, data) {
-  const { computedFields, nestedTypeFields, fields } = schema[key];
-  const computed = opts.computed;
+async function handleComputed(ctx, data) {
+  const { schema, typeName, options, db } = ctx;
+  const { computedFields, nestedTypeFields, fields } = schema[typeName];
+  const computed = options.computed;
   for (const fieldName of computedFields || []) {
-    let handler = computed[key][fieldName];
+    let handler = computed[typeName][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`);
+        throw new Error(`Computed handler for ${typeName}.${fieldName} was not found`);
     }
     const computedResults = data.map(async (doc) => {
-      doc[fieldName] = await handler({ doc });
+      doc[fieldName] = await handler({ doc, db });
     });
     await Promise.all(computedResults);
   }
@@ -355,7 +359,7 @@ async function handleComputed(schema, key, opts, data) {
         return void 0;
       if (!_.isArray(subDoc))
         subDoc = [subDoc];
-      return handleComputed(schema, fields[fieldName].type, opts, subDoc);
+      return handleComputed({ ...ctx, typeName: fields[fieldName].type }, subDoc);
     });
     await Promise.all(promises);
   }
@@ -381,6 +385,16 @@ function verifyComputedPresense(schema, computed, effects) {
     }
   }
 }
+async function handleEffectsBeforePut(ctx, docs) {
+  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
+    return [];
+  return Promise.all(ctx.effects[ctx.typeName].map((ef) => ef.beforePut?.(ctx, docs)));
+}
+async function handleEffectsAfterPut(ctx, docs, beforePutResults) {
+  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
+    return [];
+  return Promise.all(ctx.effects[ctx.typeName].map((ef, i) => ef.afterPut(ctx, docs, beforePutResults[i])));
+}
 
 function diff(object, base, includeDenormFields = false) {
   if (!base)
@@ -492,34 +506,105 @@ function validateEventSourcingSetup(schema, entityName, eventEntityName, aggrega
     }
   }
 }
-async function handleEffectsBeforePut(ctx, docs) {
-  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
-    return [];
-  return Promise.all(ctx.effects[ctx.typeName].map((ef) => ef.beforePut?.(ctx, docs)));
+
+function verifyRelationsSetup(schema, effects) {
+  for (const entityName in schema) {
+    const entity = schema[entityName];
+    for (const fName in entity.fields) {
+      const f = entity.fields[fName];
+      const denormFields = f.relationDenormFields;
+      if (!f.isRelation || !denormFields)
+        continue;
+      effects[f.type].push({
+        async afterPut(ctx, docs, beforePutResult) {
+          const { drivers } = ctx;
+          const changedDocs = docs.filter((d) => denormFields.some((f2) => !_.isEqual(d.doc[f2], d.oldDoc?.[f2])));
+          if (!changedDocs.length)
+            return;
+          const changedDocsById = _.keyBy(changedDocs, "doc.id");
+          const id_in = _.keys(changedDocsById);
+          if (!id_in.length)
+            return;
+          const affectedDocs = await drivers[entityName].getAll({
+            where: { [fName]: { id_in } },
+            maxItemCount: 1e3
+          });
+          if (!affectedDocs.length)
+            return;
+          for (const d of affectedDocs) {
+            const cd = changedDocsById[d[fName]?.id].doc;
+            if (!cd) {
+              console.warn(
+                `Error when updating denorm fields for ${entityName}.${fName}: cannot find updated ${f.type}#${d[fName]?.id}`
+              );
+              continue;
+            }
+            d[fName] = _.pick(cd, ["id", ...denormFields]);
+          }
+          await drivers[entityName].putMany(affectedDocs);
+        }
+      });
+    }
+  }
 }
-async function handleEffectsAfterPut(ctx, docs, beforePutResults) {
-  if (ctx.drivers[ctx.typeName]?.driverName === "restApi")
-    return [];
-  return Promise.all(ctx.effects[ctx.typeName].map((ef, i) => ef.afterPut(ctx, docs, beforePutResults[i])));
+async function fillDenormFieldsBeforePut(computedContext, docUpdates) {
+  const { schema, typeName, drivers } = computedContext;
+  const fields = schema[typeName].fields || {};
+  const relationsToInclude = _.values(fields).filter((f) => f.isRelation && f.relationDenormFields);
+  const docs = docUpdates.map((d) => d.doc);
+  const promises = relationsToInclude.map(async (f) => {
+    const docsWithRelation = docs.filter((d) => d[f.name]?.id);
+    const docsByRelationId = _.keyBy(docsWithRelation, `${f.name}.id`);
+    const id_in = _.keys(docsByRelationId);
+    if (!id_in)
+      return;
+    const driverInstance = drivers[f.type];
+    const relatedDocs = await driverInstance.getAll({ where: { id_in } });
+    const relatedDocsById = _.keyBy(relatedDocs, "id");
+    for (const d of docsWithRelation) {
+      const relatedDoc = relatedDocsById[d[f.name].id];
+      if (!relatedDoc) {
+        console.warn(`Relation ${f.type}#${d[f.name].id} not found for ${typeName}.${f.name}. Skipping...`);
+      }
+      d[f.name] = _.pick(relatedDoc, [...f.relationDenormFields, "id"]);
+    }
+  });
+  await Promise.all(promises);
 }
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
-  const db = { _schema: schema };
   const opts = { computed: {}, driver: memory(), ...options };
+  const db = {
+    _schema: schema,
+    uploadFile(args) {
+      if (!opts.fileUploadDriver)
+        throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
+      return opts.fileUploadDriver.uploadFile(args);
+    }
+  };
   const effects = {};
   for (const key in schema) {
     effects[key] = [];
   }
   verifyComputedPresense(schema, opts.computed);
   verifyEventSourcingSetup(schema, effects);
+  verifyRelationsSetup(schema, effects);
   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 computedContext = { schema, typeName: key, validators, options: opts, drivers, effects };
+    const computedContext = {
+      schema,
+      typeName: key,
+      validators,
+      options: opts,
+      drivers,
+      effects,
+      db
+    };
     const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
     db[handle] = {
       getAgg: async (args, ctx) => {
@@ -534,7 +619,7 @@ function generateMethods(schema, validators, options) {
         if (result && args.include)
           await handleInclude(computedContext, args.include, [result]);
         if (result)
-          await handleComputed(schema, key, opts, [result]);
+          await handleComputed(computedContext, [result]);
         return result;
       },
       getMany: async (args, ctx) => {
@@ -542,7 +627,7 @@ function generateMethods(schema, validators, options) {
         const result = await driverInstance.getMany(args, ctx);
         if (args.include)
           await handleInclude(computedContext, args.include, result.nodes);
-        await handleComputed(schema, key, opts, result.nodes);
+        await handleComputed(computedContext, result.nodes);
         return result;
       },
       getAll: async (args, ctx) => {
@@ -550,7 +635,7 @@ function generateMethods(schema, validators, options) {
         const result = await driverInstance.getAll(args, ctx);
         if (args.include)
           await handleInclude(computedContext, args.include, result);
-        await handleComputed(schema, key, opts, result);
+        await handleComputed(computedContext, result);
         return result;
       },
       put: async (doc, ctx) => {
@@ -562,10 +647,12 @@ function generateMethods(schema, validators, options) {
         if (oldDoc)
           doc = merge(oldDoc, doc);
         doc = validators[key](doc);
-        await handlePrecomputed(computedContext, [{ doc, oldDoc }]);
-        const beforePutResults = await handleEffectsBeforePut(computedContext, [{ doc, oldDoc }]);
+        const docArgsToSave = [{ doc, oldDoc }];
+        await fillDenormFieldsBeforePut(computedContext, docArgsToSave);
+        await handlePrecomputed(computedContext, docArgsToSave);
+        const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave);
         await driverInstance.put(doc, ctx);
-        await handleEffectsAfterPut(computedContext, [{ doc, oldDoc }], beforePutResults);
+        await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults);
         return doc;
       },
       putMany: async (docs, ctx) => {
@@ -584,6 +671,7 @@ function generateMethods(schema, validators, options) {
           doc = validators[key](doc);
           return { oldDoc, doc };
         });
+        await fillDenormFieldsBeforePut(computedContext, docArgsToSave);
         await handlePrecomputed(computedContext, docArgsToSave);
         const docsToSave = docArgsToSave.map((x) => x.doc);
         const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave);
@@ -600,7 +688,7 @@ async function handleInclude(computedContext, include, result) {
     return;
   const { schema, typeName, drivers } = computedContext;
   const fields = schema[typeName].fields || {};
-  const relationsToInclude = _.keys(include).filter((key) => include[key] && schema[fields[key].type].decorators.entity);
+  const relationsToInclude = _.keys(include).filter((key) => include[key] && fields[key].isRelation);
   const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
     const typeName2 = fields[fieldName].type;
     const type = schema[typeName2];

package/integrations/lib.cjs

@@ -63,6 +63,7 @@ function parseSchema(typescriptFiles) {
   }
   fillComputedDefinitionsForType(result);
   processThisReferenceDefaultValues(result, typesMap);
+  verifyRelationFields(result);
   return result;
 }
 function processThisReferenceDefaultValues(result, typesMap) {
@@ -205,6 +206,8 @@ function parseClassMember(node, parentName, ctx) {
   const decorators = parseDecorators(node.modifiers, ctx);
   const {
     isArray,
+    isRelation,
+    relationDenormFields,
     type
   } = parseFieldType(ctx, parentName, name, node, defaultValueDescription);
   const result = {
@@ -214,13 +217,17 @@ function parseClassMember(node, parentName, ctx) {
     name,
     isRequired,
     isArray,
+    isRelation,
+    relationDenormFields,
     comment
   };
   if (!_lodash.default.isEmpty(decorators)) result.decorators = decorators;
   return result;
 }
 function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
-  let isArray = false;
+  let isArray;
+  let isRelation;
+  let relationDenormFields;
   let nodeType = node?.type;
   if (nodeType?.kind === _typescript.SyntaxKind.ArrayType) {
     isArray = true;
@@ -232,6 +239,18 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
       throw new Error(`Nested arrays are not supported (${parentName})`);
     }
   }
+  if (nodeType?.kind === _typescript.SyntaxKind.TypeReference) {
+    const nt = nodeType;
+    if (nt.typeName.getText(ctx.sourceFile) === "Relation") {
+      if (!nt.typeArguments?.length) throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
+      nodeType = nt.typeArguments[0];
+      isRelation = true;
+      if (nt.typeArguments[1]) {
+        const ta = nt.typeArguments[1];
+        relationDenormFields = getRelationDenormFields(ctx, ta);
+      }
+    }
+  }
   if (nodeType?.kind === _typescript.SyntaxKind.UnionType) {
     const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
     ctx.result[newTypeName] = {
@@ -241,6 +260,8 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
     };
     return {
       isArray,
+      isRelation,
+      relationDenormFields,
       type: newTypeName
     };
   }
@@ -259,9 +280,25 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
   }
   return {
     isArray,
+    isRelation,
+    relationDenormFields,
     type
   };
 }
+function getRelationDenormFields(ctx, node) {
+  if (node.kind === _typescript.SyntaxKind.LiteralType) {
+    const literal = node.literal;
+    if (literal.kind === _typescript.SyntaxKind.StringLiteral) {
+      return [literal.text];
+    }
+    throw new Error(`Unexpected type - ${literal.getText(ctx.sourceFile)}`);
+  }
+  if (node.kind === _typescript.SyntaxKind.UnionType) {
+    const union = node;
+    return union.types.flatMap(t => getRelationDenormFields(ctx, t));
+  }
+  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
+}
 function verifyDefaultValueType(isArray, defaultValueDescription, type, supportedPrimitiveTypes2, ctx) {
   if (isArray) {
     if (defaultValueDescription.type !== "array") {
@@ -357,4 +394,15 @@ function getClassDeclarations(sourceFile) {
   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 || [];
+}
+function verifyRelationFields(result) {
+  for (const key in result) {
+    const type = result[key];
+    for (const fieldName in type.fields) {
+      const field = type.fields[fieldName];
+      if (field.isRelation && !result[field.type]?.decorators?.entity) {
+        throw new Error(`${key}.${fieldName}: Relation must point to an entity. Got "${field.type}" instead.`);
+      }
+    }
+  }
 }

package/integrations/lib.mjs

@@ -43,6 +43,7 @@ export function parseSchema(typescriptFiles) {
   }
   fillComputedDefinitionsForType(result);
   processThisReferenceDefaultValues(result, typesMap);
+  verifyRelationFields(result);
   return result;
 }
 function processThisReferenceDefaultValues(result, typesMap) {
@@ -181,14 +182,32 @@ function parseClassMember(node, parentName, ctx) {
   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);
-  const result = { type, defaultValue, defaultValueCopyFrom, name, isRequired, isArray, comment };
+  const { isArray, isRelation, relationDenormFields, type } = parseFieldType(
+    ctx,
+    parentName,
+    name,
+    node,
+    defaultValueDescription
+  );
+  const result = {
+    type,
+    defaultValue,
+    defaultValueCopyFrom,
+    name,
+    isRequired,
+    isArray,
+    isRelation,
+    relationDenormFields,
+    comment
+  };
   if (!_.isEmpty(decorators))
     result.decorators = decorators;
   return result;
 }
 function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
-  let isArray = false;
+  let isArray;
+  let isRelation;
+  let relationDenormFields;
   let nodeType = node?.type;
   if (nodeType?.kind === SyntaxKind.ArrayType) {
     isArray = true;
@@ -200,6 +219,19 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
       throw new Error(`Nested arrays are not supported (${parentName})`);
     }
   }
+  if (nodeType?.kind === SyntaxKind.TypeReference) {
+    const nt = nodeType;
+    if (nt.typeName.getText(ctx.sourceFile) === "Relation") {
+      if (!nt.typeArguments?.length)
+        throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
+      nodeType = nt.typeArguments[0];
+      isRelation = true;
+      if (nt.typeArguments[1]) {
+        const ta = nt.typeArguments[1];
+        relationDenormFields = getRelationDenormFields(ctx, ta);
+      }
+    }
+  }
   if (nodeType?.kind === SyntaxKind.UnionType) {
     const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
     ctx.result[newTypeName] = {
@@ -207,7 +239,7 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
       decorators: {},
       enumValues: getEnumValues(nodeType, node, ctx)
     };
-    return { isArray, type: newTypeName };
+    return { isArray, isRelation, relationDenormFields, type: newTypeName };
   }
   const type = nodeType?.getText(ctx.sourceFile) ?? defaultValueDescription?.type;
   if (!type)
@@ -224,7 +256,21 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
   if (defaultValueDescription && defaultValueDescription.type !== "thisReference") {
     verifyDefaultValueType(isArray, defaultValueDescription, type, supportedPrimitiveTypes, ctx);
   }
-  return { isArray, type };
+  return { isArray, isRelation, relationDenormFields, type };
+}
+function getRelationDenormFields(ctx, node) {
+  if (node.kind === SyntaxKind.LiteralType) {
+    const literal = node.literal;
+    if (literal.kind === SyntaxKind.StringLiteral) {
+      return [literal.text];
+    }
+    throw new Error(`Unexpected type - ${literal.getText(ctx.sourceFile)}`);
+  }
+  if (node.kind === SyntaxKind.UnionType) {
+    const union = node;
+    return union.types.flatMap((t) => getRelationDenormFields(ctx, t));
+  }
+  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
 }
 function verifyDefaultValueType(isArray, defaultValueDescription, type, supportedPrimitiveTypes2, ctx) {
   if (isArray) {
@@ -308,3 +354,14 @@ function getClassDeclarations(sourceFile) {
   const result = syntaxListNode?.getChildren().filter((c) => [SyntaxKind.ClassDeclaration, SyntaxKind.TypeAliasDeclaration].includes(c.kind));
   return result || [];
 }
+function verifyRelationFields(result) {
+  for (const key in result) {
+    const type = result[key];
+    for (const fieldName in type.fields) {
+      const field = type.fields[fieldName];
+      if (field.isRelation && !result[field.type]?.decorators?.entity) {
+        throw new Error(`${key}.${fieldName}: Relation must point to an entity. Got "${field.type}" instead.`);
+      }
+    }
+  }
+}

package/integrations/node.cjs

@@ -69,9 +69,13 @@ function getIndexDts(schema, options) {
     imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${key}'`);
     rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}', ${type.name}_Where>`);
     const fieldsArray = Object.values(type.fields);
+    const relations = _lodash.default.fromPairs(fieldsArray.filter(f => f.isRelation).map(f => [f.name, {
+      entity: f.type,
+      denormFields: [...(f.relationDenormFields || []), "id"].map(x => `'${x}'`).join(" | ")
+    }]));
     entityMeta.push({
       type: type.name,
-      relations: _lodash.default.fromPairs(fieldsArray.filter(f => schema[f.type]?.decorators?.entity).map(x => [x.name, x.type])),
+      relationsStr: _lodash.default.keys(relations).map(k => `${k}: { entityName: '${relations[k].entity}', entity: ${relations[k].entity}, denormFields: ${relations[k].denormFields} }`),
       aggregates: fieldsArray.filter(f => f.type === "number" && !f.isArray).map(x => `'${x.name}'`).join(" | "),
       primitives: fieldsArray.filter(f => !schema[f.type]?.decorators?.entity).map(x => `'${x.name}'`).join(" | ")
     });
@@ -86,11 +90,11 @@ ${whereFields.join("\n")}
     type: ${x.type}
     primitives: ${x.primitives || "never"}
     aggregates: ${x.aggregates || "never"}
-    relations: ${JSON.stringify(x.relations)}
+    relations: {${x.relationsStr}}
   }
       `.trim()).join("\n");
   return `
-import type { EntityMethods } from 'rads-db'
+import type { EntityMethods, FileUploadArgs } from 'rads-db'
 ${imports.join("\n")}
 
 export interface EntityMeta {
@@ -106,6 +110,7 @@ ${whereTypes.join("\n\n")}
 
 export interface RadsDb {
   _schema: any
+  uploadFile: (args: FileUploadArgs) => Promise<string>
   ${rootFields.join("\n")}
 }
   `.trim();

package/integrations/node.mjs

@@ -68,9 +68,17 @@ function getIndexDts(schema, options) {
     imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${key}'`);
     rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}', ${type.name}_Where>`);
     const fieldsArray = Object.values(type.fields);
+    const relations = _.fromPairs(
+      fieldsArray.filter((f) => f.isRelation).map((f) => [
+        f.name,
+        { entity: f.type, denormFields: [...f.relationDenormFields || [], "id"].map((x) => `'${x}'`).join(" | ") }
+      ])
+    );
     entityMeta.push({
       type: type.name,
-      relations: _.fromPairs(fieldsArray.filter((f) => schema[f.type]?.decorators?.entity).map((x) => [x.name, x.type])),
+      relationsStr: _.keys(relations).map(
+        (k) => `${k}: { entityName: '${relations[k].entity}', entity: ${relations[k].entity}, denormFields: ${relations[k].denormFields} }`
+      ),
       aggregates: fieldsArray.filter((f) => f.type === "number" && !f.isArray).map((x) => `'${x.name}'`).join(" | "),
       primitives: fieldsArray.filter((f) => !schema[f.type]?.decorators?.entity).map((x) => `'${x.name}'`).join(" | ")
     });
@@ -88,12 +96,12 @@ ${whereFields.join("\n")}
     type: ${x.type}
     primitives: ${x.primitives || "never"}
     aggregates: ${x.aggregates || "never"}
-    relations: ${JSON.stringify(x.relations)}
+    relations: {${x.relationsStr}}
   }
       `.trim()
   ).join("\n");
   return `
-import type { EntityMethods } from 'rads-db'
+import type { EntityMethods, FileUploadArgs } from 'rads-db'
 ${imports.join("\n")}
 
 export interface EntityMeta {
@@ -109,6 +117,7 @@ ${whereTypes.join("\n\n")}
 
 export interface RadsDb {
   _schema: any
+  uploadFile: (args: FileUploadArgs) => Promise<string>
   ${rootFields.join("\n")}
 }
   `.trim();

package/package.json

@@ -28,17 +28,21 @@
       "require": "./integrations/*.cjs"
     }
   },
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "keywords": [],
   "author": "",
   "license": "ISC",
   "peerDependencies": {
+    "@azure/storage-blob": ">=12",
     "@azure/cosmos": ">=3",
     "h3": "*",
     "typescript": ">=5.0.0"
   },
   "peerDependenciesMeta": {
+    "@azure/storage-blob": {
+      "optional": true
+    },
     "@azure/cosmos": {
       "optional": true
     },
@@ -72,11 +76,10 @@
     "zod": "^3.21.4"
   },
   "scripts": {
-    "predev": "pnpm link-rads-db",
     "test": "vitest --run && vitest typecheck --run",
     "link-rads-db": "symlink-dir ./test/_rads-db ./node_modules/_rads-db",
     "generate-test-schema": "rads-db",
-    "dev": "pnpm install --frozen-lockfile && vitest --ui",
+    "dev": "pnpm install --frozen-lockfile && pnpm build && pnpm generate-test-schema && pnpm link-rads-db && vitest --ui",
     "lint": "cross-env NODE_ENV=production eslint src/**/*.* test/**/*.*",
     "dev-typecheck": "vitest typecheck --ui",
     "build": "unbuild"