@btst/stack 1.8.0 → 1.9.1

package/dist/packages/better-stack/src/plugins/cms/api/plugin.cjs

@@ -111,6 +111,173 @@ function getContentTypeZodSchema(contentType) {
   const jsonSchema = JSON.parse(contentType.jsonSchema);
   return schemaConverter.formSchemaToZod(jsonSchema);
 }
+function extractRelationFields(contentType) {
+  const jsonSchema = JSON.parse(
+    contentType.jsonSchema
+  );
+  const properties = jsonSchema.properties || {};
+  const relationFields = {};
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    if (fieldSchema.fieldType === "relation" && fieldSchema.relation) {
+      relationFields[fieldName] = fieldSchema.relation;
+    }
+  }
+  return relationFields;
+}
+function isNewRelationValue(value) {
+  return typeof value === "object" && value !== null && "_new" in value && value._new === true && "data" in value;
+}
+function isExistingRelationValue(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+}
+async function processRelationsInData(adapter, contentType, data, getContentTypeFn) {
+  const relationFields = extractRelationFields(contentType);
+  const processedData = { ...data };
+  const relationIds = {};
+  for (const [fieldName, relationConfig] of Object.entries(relationFields)) {
+    if (!(fieldName in data)) {
+      continue;
+    }
+    const fieldValue = data[fieldName];
+    if (!fieldValue) {
+      relationIds[fieldName] = [];
+      continue;
+    }
+    const targetContentType = await getContentTypeFn(relationConfig.targetType);
+    if (!targetContentType) {
+      throw new Error(
+        `Target content type "${relationConfig.targetType}" not found for relation field "${fieldName}"`
+      );
+    }
+    const ids = [];
+    if (relationConfig.type === "belongsTo") {
+      const value = fieldValue;
+      if (isNewRelationValue(value)) {
+        const newItem = await createRelatedItem(
+          adapter,
+          targetContentType,
+          value.data
+        );
+        ids.push(newItem.id);
+        processedData[fieldName] = { id: newItem.id };
+      } else if (isExistingRelationValue(value)) {
+        ids.push(value.id);
+      }
+    } else {
+      const values = Array.isArray(fieldValue) ? fieldValue : [];
+      const processedValues = [];
+      for (const value of values) {
+        if (isNewRelationValue(value)) {
+          const newItem = await createRelatedItem(
+            adapter,
+            targetContentType,
+            value.data
+          );
+          ids.push(newItem.id);
+          processedValues.push({ id: newItem.id });
+        } else if (isExistingRelationValue(value)) {
+          ids.push(value.id);
+          processedValues.push({ id: value.id });
+        }
+      }
+      processedData[fieldName] = processedValues;
+    }
+    relationIds[fieldName] = ids;
+  }
+  return { processedData, relationIds };
+}
+async function createRelatedItem(adapter, targetContentType, data) {
+  const slug = utils.slugify(
+    data.slug || data.name || data.title || `item-${Date.now()}`
+  );
+  const zodSchema = getContentTypeZodSchema(targetContentType);
+  const validation = zodSchema.safeParse(data);
+  if (!validation.success) {
+    throw new Error(
+      `Validation failed for new ${targetContentType.slug}: ${JSON.stringify(validation.error.issues)}`
+    );
+  }
+  const existing = await adapter.findOne({
+    model: "contentItem",
+    where: [
+      {
+        field: "contentTypeId",
+        value: targetContentType.id,
+        operator: "eq"
+      },
+      { field: "slug", value: slug, operator: "eq" }
+    ]
+  });
+  if (existing) {
+    return existing;
+  }
+  const item = await adapter.create({
+    model: "contentItem",
+    data: {
+      contentTypeId: targetContentType.id,
+      slug,
+      data: JSON.stringify(validation.data),
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+  return item;
+}
+async function syncRelations(adapter, sourceId, relationIds) {
+  for (const [fieldName, targetIds] of Object.entries(relationIds)) {
+    await adapter.delete({
+      model: "contentRelation",
+      where: [
+        { field: "sourceId", value: sourceId, operator: "eq" },
+        { field: "fieldName", value: fieldName, operator: "eq" }
+      ]
+    });
+    for (const targetId of targetIds) {
+      await adapter.create({
+        model: "contentRelation",
+        data: {
+          sourceId,
+          targetId,
+          fieldName,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      });
+    }
+  }
+}
+async function populateRelations(adapter, item) {
+  const relations = {};
+  const contentRelations = await adapter.findMany({
+    model: "contentRelation",
+    where: [{ field: "sourceId", value: item.id, operator: "eq" }]
+  });
+  const relationsByField = {};
+  for (const rel of contentRelations) {
+    if (!relationsByField[rel.fieldName]) {
+      relationsByField[rel.fieldName] = [];
+    }
+    relationsByField[rel.fieldName].push(rel.targetId);
+  }
+  for (const [fieldName, targetIds] of Object.entries(relationsByField)) {
+    if (targetIds.length === 0) {
+      relations[fieldName] = [];
+      continue;
+    }
+    const relatedItems = [];
+    for (const targetId of targetIds) {
+      const relatedItem = await adapter.findOne({
+        model: "contentItem",
+        where: [{ field: "id", value: targetId, operator: "eq" }],
+        join: { contentType: true }
+      });
+      if (relatedItem) {
+        relatedItems.push(serializeContentItemWithType(relatedItem));
+      }
+    }
+    relations[fieldName] = relatedItems;
+  }
+  return relations;
+}
 const cmsBackendPlugin = (config) => api.defineBackendPlugin({
   name: "cms",
   dbPlugin: db.cmsSchema,
@@ -278,8 +445,14 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
         if (!contentType) {
           throw ctx.error(404, { message: "Content type not found" });
         }
+        const { processedData: dataWithResolvedRelations, relationIds } = await processRelationsInData(
+          adapter,
+          contentType,
+          data,
+          getContentType
+        );
         const zodSchema = getContentTypeZodSchema(contentType);
-        const validation = zodSchema.safeParse(data);
+        const validation = zodSchema.safeParse(dataWithResolvedRelations);
         if (!validation.success) {
           throw ctx.error(400, {
             message: "Validation failed",
@@ -302,36 +475,34 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
             message: "Content item with this slug already exists"
           });
         }
-        let finalData = validation.data;
+        const processedData = validation.data;
         if (config.hooks?.onBeforeCreate) {
           const result = await config.hooks.onBeforeCreate(
-            validation.data,
+            processedData,
             context
           );
           if (result === false) {
             throw ctx.error(403, { message: "Create operation denied" });
           }
-          if (result && typeof result === "object") {
-            finalData = result;
-          }
         }
         const item = await adapter.create({
           model: "contentItem",
           data: {
             contentTypeId: contentType.id,
             slug,
-            data: JSON.stringify(finalData),
+            data: JSON.stringify(processedData),
             createdAt: /* @__PURE__ */ new Date(),
             updatedAt: /* @__PURE__ */ new Date()
           }
         });
+        await syncRelations(adapter, item.id, relationIds);
         const serialized = serializeContentItem(item);
         if (config.hooks?.onAfterCreate) {
           await config.hooks.onAfterCreate(serialized, context);
         }
         return {
           ...serialized,
-          parsedData: finalData
+          parsedData: processedData
         };
       }
     );
@@ -385,10 +556,27 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
             });
           }
         }
-        let validatedData = data;
+        let dataWithResolvedRelations;
+        let relationIds;
         if (data) {
+          const result = await processRelationsInData(
+            adapter,
+            contentType,
+            data,
+            getContentType
+          );
+          dataWithResolvedRelations = result.processedData;
+          relationIds = result.relationIds;
+        }
+        let validatedData = dataWithResolvedRelations;
+        if (dataWithResolvedRelations) {
+          const existingData = existing.data ? JSON.parse(existing.data) : {};
+          const mergedData = {
+            ...existingData,
+            ...dataWithResolvedRelations
+          };
           const zodSchema = getContentTypeZodSchema(contentType);
-          const validation = zodSchema.safeParse(data);
+          const validation = zodSchema.safeParse(mergedData);
           if (!validation.success) {
             throw ctx.error(400, {
               message: "Validation failed",
@@ -397,7 +585,7 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
           }
           validatedData = validation.data;
         }
-        let finalData = validatedData;
+        const processedData = validatedData;
         if (config.hooks?.onBeforeUpdate && validatedData) {
           const result = await config.hooks.onBeforeUpdate(
             id,
@@ -407,15 +595,15 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
           if (result === false) {
             throw ctx.error(403, { message: "Update operation denied" });
           }
-          if (result && typeof result === "object") {
-            finalData = result;
-          }
+        }
+        if (relationIds) {
+          await syncRelations(adapter, id, relationIds);
         }
         const updateData = {
           updatedAt: /* @__PURE__ */ new Date()
         };
         if (slug) updateData.slug = slug;
-        if (finalData) updateData.data = JSON.stringify(finalData);
+        if (processedData) updateData.data = JSON.stringify(processedData);
         await adapter.update({
           model: "contentItem",
           where: [{ field: "id", value: id, operator: "eq" }],
@@ -472,6 +660,243 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
         return { success: true };
       }
     );
+    const getContentItemPopulated = api.createEndpoint(
+      "/content/:typeSlug/:id/populated",
+      {
+        method: "GET",
+        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
+      },
+      async (ctx) => {
+        const { typeSlug, id } = ctx.params;
+        const contentType = await getContentType(typeSlug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const item = await adapter.findOne({
+          model: "contentItem",
+          where: [{ field: "id", value: id, operator: "eq" }],
+          join: { contentType: true }
+        });
+        if (!item || item.contentTypeId !== contentType.id) {
+          throw ctx.error(404, { message: "Content item not found" });
+        }
+        const _relations = await populateRelations(adapter, item);
+        return {
+          ...serializeContentItemWithType(item),
+          _relations
+        };
+      }
+    );
+    const listContentByRelation = api.createEndpoint(
+      "/content/:typeSlug/by-relation",
+      {
+        method: "GET",
+        params: z.z.object({ typeSlug: z.z.string() }),
+        query: z.z.object({
+          field: z.z.string(),
+          targetId: z.z.string(),
+          limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+          offset: z.z.coerce.number().min(0).optional().default(0)
+        })
+      },
+      async (ctx) => {
+        const { typeSlug } = ctx.params;
+        const { field, targetId, limit, offset } = ctx.query;
+        const contentType = await getContentType(typeSlug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const contentRelations = await adapter.findMany({
+          model: "contentRelation",
+          where: [
+            { field: "targetId", value: targetId, operator: "eq" },
+            { field: "fieldName", value: field, operator: "eq" }
+          ]
+        });
+        const sourceIds = [
+          ...new Set(contentRelations.map((r) => r.sourceId))
+        ];
+        if (sourceIds.length === 0) {
+          return {
+            items: [],
+            total: 0,
+            limit,
+            offset
+          };
+        }
+        const allItems = [];
+        for (const sourceId of sourceIds) {
+          const item = await adapter.findOne({
+            model: "contentItem",
+            where: [
+              { field: "id", value: sourceId, operator: "eq" },
+              {
+                field: "contentTypeId",
+                value: contentType.id,
+                operator: "eq"
+              }
+            ],
+            join: { contentType: true }
+          });
+          if (item) {
+            allItems.push(item);
+          }
+        }
+        allItems.sort(
+          (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+        );
+        const total = allItems.length;
+        const paginatedItems = allItems.slice(offset, offset + limit);
+        return {
+          items: paginatedItems.map(serializeContentItemWithType),
+          total,
+          limit,
+          offset
+        };
+      }
+    );
+    const getInverseRelations = api.createEndpoint(
+      "/content-types/:slug/inverse-relations",
+      {
+        method: "GET",
+        params: z.z.object({ slug: z.z.string() }),
+        query: z.z.object({
+          itemId: z.z.string().optional()
+        })
+      },
+      async (ctx) => {
+        const { slug } = ctx.params;
+        const { itemId } = ctx.query;
+        await ensureSynced();
+        const targetContentType = await getContentType(slug);
+        if (!targetContentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const allContentTypes = await adapter.findMany({
+          model: "contentType"
+        });
+        const inverseRelations = [];
+        for (const contentType of allContentTypes) {
+          const relationFields = extractRelationFields(contentType);
+          for (const [fieldName, relationConfig] of Object.entries(
+            relationFields
+          )) {
+            if (relationConfig.type === "belongsTo" && relationConfig.targetType === slug) {
+              let count = 0;
+              if (itemId) {
+                const relations = await adapter.findMany({
+                  model: "contentRelation",
+                  where: [
+                    {
+                      field: "targetId",
+                      value: itemId,
+                      operator: "eq"
+                    },
+                    {
+                      field: "fieldName",
+                      value: fieldName,
+                      operator: "eq"
+                    }
+                  ]
+                });
+                const itemIds = relations.map((r) => r.sourceId);
+                for (const sourceId of itemIds) {
+                  const item = await adapter.findOne({
+                    model: "contentItem",
+                    where: [
+                      {
+                        field: "id",
+                        value: sourceId,
+                        operator: "eq"
+                      },
+                      {
+                        field: "contentTypeId",
+                        value: contentType.id,
+                        operator: "eq"
+                      }
+                    ]
+                  });
+                  if (item) count++;
+                }
+              }
+              inverseRelations.push({
+                sourceType: contentType.slug,
+                sourceTypeName: contentType.name,
+                fieldName,
+                count
+              });
+            }
+          }
+        }
+        return { inverseRelations };
+      }
+    );
+    const listInverseRelationItems = api.createEndpoint(
+      "/content-types/:slug/inverse-relations/:sourceType",
+      {
+        method: "GET",
+        params: z.z.object({
+          slug: z.z.string(),
+          sourceType: z.z.string()
+        }),
+        query: z.z.object({
+          itemId: z.z.string(),
+          fieldName: z.z.string(),
+          limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+          offset: z.z.coerce.number().min(0).optional().default(0)
+        })
+      },
+      async (ctx) => {
+        const { slug, sourceType } = ctx.params;
+        const { itemId, fieldName, limit, offset } = ctx.query;
+        await ensureSynced();
+        const targetContentType = await getContentType(slug);
+        if (!targetContentType) {
+          throw ctx.error(404, { message: "Target content type not found" });
+        }
+        const sourceContentType = await getContentType(sourceType);
+        if (!sourceContentType) {
+          throw ctx.error(404, { message: "Source content type not found" });
+        }
+        const relations = await adapter.findMany({
+          model: "contentRelation",
+          where: [
+            { field: "targetId", value: itemId, operator: "eq" },
+            { field: "fieldName", value: fieldName, operator: "eq" }
+          ]
+        });
+        const sourceIds = [...new Set(relations.map((r) => r.sourceId))];
+        const allItems = [];
+        for (const sourceId of sourceIds) {
+          const item = await adapter.findOne({
+            model: "contentItem",
+            where: [
+              { field: "id", value: sourceId, operator: "eq" },
+              {
+                field: "contentTypeId",
+                value: sourceContentType.id,
+                operator: "eq"
+              }
+            ],
+            join: { contentType: true }
+          });
+          if (item) {
+            allItems.push(item);
+          }
+        }
+        allItems.sort(
+          (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+        );
+        const total = allItems.length;
+        const paginatedItems = allItems.slice(offset, offset + limit);
+        return {
+          items: paginatedItems.map(serializeContentItemWithType),
+          total,
+          limit,
+          offset
+        };
+      }
+    );
     return {
       listContentTypes,
       getContentTypeBySlug,
@@ -479,7 +904,11 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
       getContentItem,
       createContentItem,
       updateContentItem,
-      deleteContentItem
+      deleteContentItem,
+      getContentItemPopulated,
+      listContentByRelation,
+      getInverseRelations,
+      listInverseRelationItems
     };
   }
 });