@strifeapp/astro 1.0.7 → 1.0.9

package/dist/index.js

@@ -1,5 +1,5 @@
 import { loadEnv as f } from "vite";
-import r from "serialize-javascript";
+import a from "serialize-javascript";
 const y = `/**
  * Creates an indexed item that will be stored in the index.
  * @param {string} name - Name of property to index
@@ -7,240 +7,293 @@ const y = `/**
  * @returns a new object to index and store
  */
 function storeAs(name, value) {
-  return {
+    return {
       $value: value,
       $name: name,
-      $options: { storage: true }
-  };
-}
+      $options: { storage: true },
+    };
+  }
 
-/**
-* Create an indexed item without storing value in the index.
-* @param {string} name - Name of the property to index
-* @param {any} value - The value to index
-* @returns a new object to index (no store)
-*/
-function indexAs(name, value) {
-  return {
+  /**
+   * Create an indexed item without storing value in the index.
+   * @param {string} name - Name of the property to index
+   * @param {any} value - The value to index
+   * @returns a new object to index (no store)
+   */
+  function indexAs(name, value) {
+    return {
       $value: value,
       $name: name,
-      $options: { storage: false }
-  };
-}
+      $options: { storage: false },
+    };
+  }
 
-/**
-* Loads the documents referenced by reference objects in the array
-* @param {any} references - Array of document references: { id, collection }
-* @returns The list of loaded documents.
-*/
-function loadRelatedDocuments(references) {
-  if (references == null) return null;
-  return references
-      .filter(item => typeof item.id === "string") // Ensure each ID is a string
-      .map(item => load(item.id, 'Labels'))
+  /**
+   * Loads the documents referenced by reference objects in the array
+   * @param {any} references - Array of document references: { id, collection }
+   * @returns The list of loaded documents.
+   */
+  function loadRelatedDocuments(references) {
+    if (references == null) return null;
+    return references
+      .filter((item) => typeof item.id === 'string') // Ensure each ID is a string
+      .map((item) => load(item.id, 'Labels'))
       .filter(Boolean); // Filter out any null/undefined values
-}
-
+  }
 
-/**
-* Builds an url for a document by traversing its ancestor origins
-* @param {*} doc - The leaf document
-* @returns The full url of the document
-*/
-function buildUrl(doc) {
-  const visited = {};
-  const slugs = [];
-  let c = doc;
+  /**
+   * Builds an url for a document by traversing its ancestor origins
+   * @param {*} doc - The leaf document
+   * @returns The full url of the document
+   */
+  function buildUrl(doc) {
+    const visited = {};
+    const slugs = [];
+    let c = doc;
 
-  do {
+    do {
       if (c.slug) {
-          slugs.unshift(c.slug);
+        slugs.unshift(c.slug);
       }
       if (!c.origin || visited[c.origin.id]) break;
       visited[c.origin.id] = true;
       c = load(c.origin.id, c.origin.collection);
-  } while (c);
+    } while (c);
 
-  return slugs.shift() + slugs.join('/');
-}
+    return slugs.shift() + slugs.join('/');
+  }
 
-/**
-* Editor types that contains {collection, id} references that we want to load
-*/
-const RELATION_EDITORS = ["related", "references"];
-
-/**
-* Loads the template document of the specified document
-* @param {any} document - The document to index
-* @returns The document's template, loaded
-*/
-function loadTemplate(document) {
-  const collection = document['@metadata']['@collection'];
-  const template = load('templates/' + collection, 'templates');
-  return template;
-}
+  /**
+   * Editor types that contains {collection, id} references that we want to load
+   */
+  const RELATION_EDITORS = ['related', 'references'];
+
+  /**
+   * Loads the template document of the specified document
+   * @param {any} document - The document to index
+   * @returns The document's template, loaded
+   */
+  function loadTemplate(document) {
+    const collection = document['@metadata']['@collection'];
+    const template = load('templates/' + collection, 'templates');
+    return template;
+  }
+
+  /**
+   * Loads the metadata template
+   * @returns The metadata template
+   */
+  function loadMetadataTemplate() {
+    const template = load('templates/metadata', 'templates');
+    return template;
+  }
 
-/**
-* Iterates the template's editors and copies the respective values to the
-* result object. Properties containing references are resolved recursively.
-* Mutually recursive with \`loadRelatedDocumentsRecurse\`.
-* @param {*} document - The document to extract values from
-* @param {*} template - The document's template
-* @param {*} result - The populated result
-*/
-function populateValuesByEditor(document, template, result) {
-  // Add dynamic fields and handle "related" type
-  template.editors.forEach(editor => {
+  /**
+   * Iterates the template's editors and copies the respective values to the
+   * result object. Properties containing references are resolved recursively.
+   * Mutually recursive with \`loadRelatedDocumentsRecurse\`.
+   * @param {*} document - The document to extract values from
+   * @param {*} template - The document's template
+   * @param {*} metadataTemplate - The metadata template
+   * @param {*} result - The populated result
+   */
+  function populateValuesByEditor(document, template, metadataTemplate, result, loadedDocs) {
+    const aggregatedEditors = template.editors.concat(metadataTemplate.editors);
+    // Add dynamic fields and handle "related" type
+    aggregatedEditors.forEach((editor) => {
       if (editor.editor && editor.editor.propertyName) {
-          const propertyName = editor.editor.propertyName;
-
-          if (RELATION_EDITORS.includes(editor.editor.type) && Array.isArray(document[propertyName])) {
-              // Load related documents in the array of document references
-              const relatedDocs = loadRelatedDocumentsRecurse(document[propertyName])
-              result[propertyName] = relatedDocs;
-          } else if (document[propertyName] !== undefined) {
-              // For other types, index the field value directly
-              result[propertyName] = document[propertyName];
+        const propertyName = editor.editor.propertyName;
+
+        if (RELATION_EDITORS.includes(editor.editor.type) && Array.isArray(document[propertyName])) {
+          // Load related documents in the array of document references
+          const relatedDocs = loadRelatedDocumentsRecurse(document[propertyName], metadataTemplate, loadedDocs);
+          result[propertyName] = relatedDocs;
+        } else if (editor.editor.type === 'content-template') {
+          const content = document[propertyName];
+          if (content) {
+            const contentTemplate = load(editor.editor.attributes.templateId, 'templates');
+            const docResult = {};
+            populateValuesByEditor(content, contentTemplate, metadataTemplate, docResult, loadedDocs);
+            result[propertyName] = docResult;
+          }
+        } else if (editor.editor.type === 'chapters') {
+          const chapters = document[propertyName];
+          if (chapters && Array.isArray(chapters)) {
+            const docResults = [];
+            chapters.forEach((chapter) => {
+              if (chapter['@strife'] && chapter['@strife'].templateId) {
+                const docResult = {};
+                const chaptersTemplate = load(chapter['@strife'].templateId, 'templates');
+                populateValuesByEditor(chapter, chaptersTemplate, metadataTemplate, docResult, loadedDocs);
+                docResults.push(docResult);
+              }
+            });
+            result[propertyName] = docResults;
           }
+        } else if (document[propertyName] !== undefined) {
+          // For other types, index the field value directly
+          result[propertyName] = document[propertyName];
+        }
       }
-  });
-  if (document['@strife']) {
+    });
+    if (document['@strife']) {
       result['@strife'] = document['@strife'];
+    }
   }
-}
 
-/**
-* Loads the documents referenced by the array of references. Mutually recursive
-* with \`populateValuesByEditor\`.
-* @param {*} references - List of references to load.
-* @returns
-*/
-function loadRelatedDocumentsRecurse(references) {
-  if (references == null) return null;
-  const documents = references
-      //.filter(id => typeof id === "string" || (typeof id === "object" && id.id)) // Ensure each ID is a string or object with an id
-      .map(id => (typeof id === "string" ? id : id.id))
-      .map(id => (load(id, 'Contacts') || load(id, 'Articles') || load(id, 'ContentTexts') || load(id, 'Notices') || load(id, 'EducationPages')))
+  /**
+   * Loads the documents referenced by the array of references. Mutually recursive
+   * with \`populateValuesByEditor\`.
+   * @param {*} references - List of references to load.
+   * @returns
+   */
+  function loadRelatedDocumentsRecurse(references, metadataTemplate, loadedDocs) {
+    if (references == null) return null;
+    const documents = references
+      .map((id) => (typeof id === 'string' ? id : id.id))
+      .map((id) => {
+        if (loadedDocs.has(id)) return null;
+
+        const aDoc = load(id, '@all_docs');
+
+        if (aDoc) {
+          loadedDocs.add(id);
+        }
+        return aDoc;
+      })
       .filter(Boolean); // Filter out any null/undefined values
 
-  const docResults = [];
-  documents.forEach(doc => {
+    const docResults = [];
+    documents.forEach((doc) => {
       const template = loadTemplate(doc);
       const docResult = {
-          id: Id(doc),
-          url: buildUrl(doc),
-          collection: doc['@metadata']['@collection'],
-          labels: loadRelatedDocuments(
-              doc.labels.map(l => { return { id: l, collection: "Labels" } })),
+        id: Id(doc),
+        url: buildUrl(doc),
+        collection: doc['@metadata']['@collection'],
+        labels: loadRelatedDocuments(
+          doc.labels.map((l) => {
+            return { id: l, collection: 'Labels' };
+          }),
+        ),
       };
-      populateValuesByEditor(doc, template, docResult);
-      docResults.push(docResult)
-  });
+      populateValuesByEditor(doc, template, metadataTemplate, docResult, loadedDocs);
+      docResults.push(docResult);
+    });
 
-  return docResults;
-}
+    return docResults;
+  }
 
-/**
-* Maps a document to an index entry for Strife's content index
-* @param {any} document - The document to index
-* @returns An object to be indexed by RavenDB
-*/
-function mapDocument(document) {
-  const collection = document['@metadata']['@collection'];
-  const template = load('templates/' + collection, 'templates');
+  /**
+   * Maps a document to an index entry for Strife's content index
+   * @param {any} document - The document to index
+   * @returns An object to be indexed by RavenDB
+   */
+  function mapDocument(document) {
+    const collection = document['@metadata']['@collection'];
+    const template = load('templates/' + collection, 'templates');
 
-  if (!template || !template.editors || document.deleted || document.archived) {
+    if (!template || !template.editors || document.deleted || document.archived) {
       return null;
-  }
+    }
+
+    const metadataTemplate = loadMetadataTemplate();
 
-  // Initialize result with static fields
-  const result = {
+    // Initialize result with static fields
+    const result = {
       id: Id(document),
       displayName: document.displayName,
       url: storeAs('url', buildUrl(document)),
       origin: document.origin,
       collection: storeAs('collection', collection),
-      publishedDate: document.publishedDate,
-      createdAt: document.createdAt,
-      labels: storeAs('labels', loadRelatedDocuments(
-          document.labels.map(l => { return { id: l, collection: "Labels" } }))),
+      publishedDate: storeAs('publishedAt', document.publishedDate),
+      createdAt: storeAs('createdAt', document.createdAt),
+      changedAt: storeAs('changedAt', document.changedAt),
+      labels: storeAs(
+        'labels',
+        loadRelatedDocuments(
+          document.labels.map((l) => {
+            return { id: l, collection: 'Labels' };
+          }),
+        ),
+      ),
       deleted: document.deleted,
-  };
+    };
+
+    // Keep tabs of loaded documents to avoid infinite recursion
+    const loadedDocuments = new Set(result.id);
 
-  // Add dynamic fields and handle "related" type
-  template.editors.forEach(editor => {
+    // Add dynamic fields and handle "related" type
+    template.editors.forEach((editor) => {
       if (editor.editor && editor.editor.propertyName) {
-          const propertyName = editor.editor.propertyName;
-
-          if (RELATION_EDITORS.includes(editor.editor.type) && Array.isArray(document[propertyName])) {
-              // Load related documents in the array of document references
-              const relatedDocs = loadRelatedDocumentsRecurse(document[propertyName]);
-              result[propertyName] = storeAs(propertyName, relatedDocs);
-          } else if (editor.editor.type === 'content-template') {
-              const content = document[propertyName];
-              if (content) {
-                  const template = load(editor.editor.attributes.templateId, 'templates');
-                  const docResult = {};
-                  populateValuesByEditor(content, template, docResult);
-                  result[propertyName] = storeAs(propertyName, docResult);
-              }
-          } else if (editor.editor.type === 'chapters') {
-              const chapters = document[propertyName];
-              if (chapters && Array.isArray(chapters)) {
-                  const docResults = [];
-                  chapters.forEach(chapter => {
-                      if (chapter['@strife'] && chapter['@strife'].templateId) {
-                          const docResult = {};
-                          const template = load(chapter['@strife'].templateId, 'templates');
-                          populateValuesByEditor(chapter, template, docResult);
-                          docResults.push(docResult);
-                      }
-                  });
-                  result[propertyName] = storeAs(propertyName, docResults);
-              }
+        const propertyName = editor.editor.propertyName;
+
+        if (RELATION_EDITORS.includes(editor.editor.type) && Array.isArray(document[propertyName])) {
+          // Load related documents in the array of document references
+          const relatedDocs = loadRelatedDocumentsRecurse(document[propertyName], metadataTemplate, loadedDocuments);
+          result[propertyName] = storeAs(propertyName, relatedDocs);
+        } else if (editor.editor.type === 'content-template') {
+          const content = document[propertyName];
+          if (content) {
+            const template = load(editor.editor.attributes.templateId, 'templates');
+            const docResult = {};
+            populateValuesByEditor(content, template, metadataTemplate, docResult, loadedDocuments);
+            result[propertyName] = storeAs(propertyName, docResult);
           }
-          else if (document[propertyName] !== undefined) {
-              // For other types, index the field value directly
-              result[propertyName] = indexAs(propertyName, document[propertyName]);
+        } else if (editor.editor.type === 'chapters') {
+          const chapters = document[propertyName];
+          if (chapters && Array.isArray(chapters)) {
+            const docResults = [];
+            chapters.forEach((chapter) => {
+              if (chapter['@strife'] && chapter['@strife'].templateId) {
+                const docResult = {};
+                const template = load(chapter['@strife'].templateId, 'templates');
+                populateValuesByEditor(chapter, template, metadataTemplate, docResult, loadedDocuments);
+                docResults.push(docResult);
+              }
+            });
+            result[propertyName] = storeAs(propertyName, docResults);
           }
+        } else if (document[propertyName] !== undefined) {
+          // For other types, index the field value directly
+          result[propertyName] = indexAs(propertyName, document[propertyName]);
+        }
       }
-  });
+    });
 
-  return result;
-}
-`, d = "strife:store", i = "\0" + d;
+    return result;
+  }`, l = "strife:store", d = "\0" + l;
 function h(e) {
   return {
     name: "strife:store",
     resolveId(o) {
-      if (o === d)
-        return i;
+      if (o === l)
+        return d;
     },
     load(o) {
       var t;
-      if (o === i)
+      if (o === d)
         return `
           import { DocumentStore, AbstractJavaScriptMultiMapIndexCreationTask, IndexCreation } from "ravendb";
 
           const authOptions = {
             type: 'pfx',
-            certificate: Buffer.from(${r(e.certificate)}, 'base64'),
-            password: ${r(e.password)},
+            certificate: Buffer.from(${a(e.certificate)}, 'base64'),
+            password: ${a(e.password)},
           };
 
           const store = new DocumentStore(
-            ${r(e.urls ? e.urls : [])},
-            ${r(e.database || "")},
+            ${a(e.urls ? e.urls : [])},
+            ${a(e.database || "")},
             authOptions
           ).initialize()
 
-          class Content_ByUrlzz extends AbstractJavaScriptMultiMapIndexCreationTask {
+          class Content_ByUrl extends AbstractJavaScriptMultiMapIndexCreationTask {
             constructor() {
               super();
 
-              this.additionalSources = {"Helper": ${r(y)}}
+              this.additionalSources = {"Helper": ${a(y)}}
 
-              ${(e.collections || ["Posts"]).map((n) => `this.map("${typeof n == "string" ? n : n.name}", (doc) => mapDocument(doc));`).join(`
+              ${(e.collections || ["Posts"]).map((n) => `this.map("${typeof n == "string" ? n : n.name}", (doc) =>  { return });`).join(`
 `)}
 
               this.deploymentMode = 'Rolling';
@@ -249,12 +302,13 @@ function h(e) {
           }
 
           console.log('Deploying index...');
-          await IndexCreation.createIndexes([new Content_ByUrlzz()], store);
+
+          await IndexCreation.createIndexes([new Content_ByUrl()], store);
 
           const bulkInsert = store.bulkInsert();
 
           ${(t = e.collections) == null ? void 0 : t.map((n) => `
-            bulkInsert.store(${JSON.stringify(n)}, 'templates/${n.name}', { '@collection': 'Templates' });
+            await bulkInsert.store(${JSON.stringify(n)}, 'templates/${n.name}', { '@collection': 'Templates' });
           `).join(`
 `)}
 
@@ -265,33 +319,33 @@ function h(e) {
     }
   };
 }
-const v = {
+const T = {
   type: "pfx"
 };
-function N(e) {
+function b(e) {
   let o, t;
   return {
     name: "@strife/astro",
     hooks: {
-      "astro:config:setup": ({ command: n, config: a, updateConfig: l }) => {
+      "astro:config:setup": ({ command: n, config: r, updateConfig: c }) => {
         var s;
-        o = n, t = f(o, a.vite.envDir ?? "", "");
-        const c = {
+        o = n, t = f(o, r.vite.envDir ?? "", "");
+        const i = {
           urls: (s = t.STRIFE_DATABASE_URLS) == null ? void 0 : s.split(","),
           database: t.STRIFE_DATABASE,
           certificate: t.STRIFE_CERTIFICATE,
           password: t.STRIFE_CERTIFICATE_PASSWORD
         }, u = Object.fromEntries(
-          Object.entries(c).filter(([R, m]) => m !== void 0)
+          Object.entries(i).filter(([R, m]) => m !== void 0)
         ), p = {
-          ...v,
+          ...T,
           // Base defaults
           ...u,
           // Environment variables override defaults
           ...e
           // Explicit options override everything
         };
-        l({
+        c({
           vite: {
             plugins: [
               h(p)
@@ -303,5 +357,5 @@ function N(e) {
   };
 }
 export {
-  N as default
+  b as default
 };

package/dist/services/ImageService.d.ts

@@ -0,0 +1,3 @@
+import { ImageService } from 'astro';
+declare const service: ImageService;
+export default service;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strifeapp/astro",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Official Strife Astro integration",
   "keywords": [
     "astro-integration",