@strifeapp/astro 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -1,10 +1,14 @@
-import type { AstroIntegration } from 'astro';
-import type { IAuthOptions } from 'ravendb';
-export type IntegrationOptions = IAuthOptions & {
+import { AstroIntegration } from 'astro';
+import { IAuthOptions } from 'ravendb';
+export interface IntegrationOptions extends IAuthOptions {
     certificate?: string;
     password?: string;
     urls?: string[];
     database?: string;
-    collections?: any[];
-};
+    collections?: Collection[];
+}
+export interface Collection {
+    name: string;
+    [key: string]: any;
+}
 export default function strifeIntegration(options?: IntegrationOptions): AstroIntegration;

package/dist/index.js

@@ -1,39 +1,307 @@
-import { loadEnv } from "vite";
-// Import the vite plugin directly from the file
-import { vitePluginStrifeStore } from './vite-plugin-strife-store.js';
-const defaultClientConfig = {
-    type: 'pfx',
+import { loadEnv as f } from "vite";
+import r from "serialize-javascript";
+const y = `/**
+ * Creates an indexed item that will be stored in the index.
+ * @param {string} name - Name of property to index
+ * @param {any} value - Value to index and store
+ * @returns a new object to index and store
+ */
+function storeAs(name, value) {
+  return {
+      $value: value,
+      $name: name,
+      $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 {
+      $value: value,
+      $name: name,
+      $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'))
+      .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;
+
+  do {
+      if (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);
+
+  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;
+}
+
+/**
+* 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 => {
+      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];
+          }
+      }
+  });
+  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')))
+      .filter(Boolean); // Filter out any null/undefined values
+
+  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" } })),
+      };
+      populateValuesByEditor(doc, template, docResult);
+      docResults.push(docResult)
+  });
+
+  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');
+
+  if (!template || !template.editors || document.deleted || document.archived) {
+      return null;
+  }
+
+  // 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" } }))),
+      deleted: document.deleted,
+  };
+
+  // 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);
+              }
+          }
+          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;
+function h(e) {
+  return {
+    name: "strife:store",
+    resolveId(o) {
+      if (o === d)
+        return i;
+    },
+    load(o) {
+      var t;
+      if (o === i)
+        return `
+          import { DocumentStore, AbstractJavaScriptMultiMapIndexCreationTask, IndexCreation } from "ravendb";
+
+          const authOptions = {
+            type: 'pfx',
+            certificate: Buffer.from(${r(e.certificate)}, 'base64'),
+            password: ${r(e.password)},
+          };
+
+          const store = new DocumentStore(
+            ${r(e.urls ? e.urls : [])},
+            ${r(e.database || "")},
+            authOptions
+          ).initialize()
+
+          class Content_ByUrlzz extends AbstractJavaScriptMultiMapIndexCreationTask {
+            constructor() {
+              super();
+
+              this.additionalSources = {"Helper": ${r(y)}}
+
+              ${(e.collections || ["Posts"]).map((n) => `this.map("${typeof n == "string" ? n : n.name}", (doc) => mapDocument(doc));`).join(`
+`)}
+
+              this.deploymentMode = 'Rolling';
+              this.searchEngineType = 'Lucene';
+            }
+          }
+
+          console.log('Deploying index...');
+          await IndexCreation.createIndexes([new Content_ByUrlzz()], store);
+
+          const bulkInsert = store.bulkInsert();
+
+          ${(t = e.collections) == null ? void 0 : t.map((n) => `
+            bulkInsert.store(${JSON.stringify(n)}, 'templates/${n.name}', { '@collection': 'Templates' });
+          `).join(`
+`)}
+
+          await bulkInsert.finish();
+
+          export { store };
+        `;
+    }
+  };
+}
+const v = {
+  type: "pfx"
 };
-export default function strifeIntegration(options = {}) {
-    let mode;
-    let env;
-    return {
-        name: '@strife/astro',
-        hooks: {
-            'astro:config:setup': ({ command, config, updateConfig }) => {
-                mode = command;
-                env = loadEnv(mode, config.vite.envDir ?? '', '');
-                const envOptions = {
-                    urls: env.STRIFE_DATABASE_URLS?.split(','),
-                    database: env.STRIFE_DATABASE,
-                    certificate: env.STRIFE_CERTIFICATE,
-                    password: env.STRIFE_CERTIFICATE_PASSWORD
-                };
-                // Filter out undefined values from env
-                const filteredEnvOptions = Object.fromEntries(Object.entries(envOptions).filter(([_, value]) => value !== undefined));
-                const mergedOptions = {
-                    ...defaultClientConfig, // Base defaults
-                    ...filteredEnvOptions, // Environment variables override defaults
-                    ...options // Explicit options override everything
-                };
-                updateConfig({
-                    vite: {
-                        plugins: [
-                            vitePluginStrifeStore(mergedOptions)
-                        ],
-                    }
-                });
-            },
-        }
-    };
+function N(e) {
+  let o, t;
+  return {
+    name: "@strife/astro",
+    hooks: {
+      "astro:config:setup": ({ command: n, config: a, updateConfig: l }) => {
+        var s;
+        o = n, t = f(o, a.vite.envDir ?? "", "");
+        const c = {
+          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)
+        ), p = {
+          ...v,
+          // Base defaults
+          ...u,
+          // Environment variables override defaults
+          ...e
+          // Explicit options override everything
+        };
+        l({
+          vite: {
+            plugins: [
+              h(p)
+            ]
+          }
+        });
+      }
+    }
+  };
 }
+export {
+  N as default
+};

package/dist/vite-plugin-strife-store.d.ts

@@ -1,3 +1,3 @@
-import type { IntegrationOptions } from './index';
-import type { PluginOption } from 'vite';
+import { IntegrationOptions } from './index';
+import { PluginOption } from 'vite';
 export declare function vitePluginStrifeStore(config: IntegrationOptions): PluginOption;

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "@strifeapp/astro",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Official Strife Astro integration",
   "keywords": [
     "astro-integration",
     "withastro",
     "strife"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "vite build && tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && vite build",
     "prepublishOnly": "npm run build"
   },
   "exports": {
-    ".": "./dist/index.js",
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
     "./vite-plugin-strife-store": "./dist/vite-plugin-strife-store-entry.js",
     "./module": "./module.d.ts"
   },
@@ -30,6 +35,7 @@
   },
   "devDependencies": {
     "@types/dotenv": "^8.2.0",
+    "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vite": "^6.2.1",
     "vite-plugin-dts": "^4.5.3"
@@ -37,5 +43,10 @@
   "peerDependencies": {
     "astro": "^4.0.0 || ^5.0.0",
     "ravendb": "^6.0.0"
+  },
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist"
   }
 }

package/dist/vite-plugin-strife-store-entry.js

@@ -1,2 +0,0 @@
-// This file serves as an entry point for the vite-plugin-strife-store module
-export * from './vite-plugin-strife-store';

package/dist/vite-plugin-strife-store.js

@@ -1,59 +0,0 @@
-import serialize from 'serialize-javascript';
-import contentIndex from './contentIndex.js?raw';
-const virtualModuleId = 'strife:store';
-const resolvedVirtualModuleId = '\0' + virtualModuleId;
-export function vitePluginStrifeStore(config) {
-    return {
-        name: 'strife:store',
-        resolveId(id) {
-            if (id === virtualModuleId) {
-                return resolvedVirtualModuleId;
-            }
-        },
-        load(id) {
-            if (id === resolvedVirtualModuleId) {
-                return `
-          import { DocumentStore, AbstractJavaScriptMultiMapIndexCreationTask, IndexCreation } from "ravendb";
-
-          const authOptions = {
-            type: 'pfx',
-            certificate: Buffer.from(${serialize(config.certificate)}, 'base64'),
-            password: ${serialize(config.password)},
-          };
-
-          const store = new DocumentStore(
-            ${serialize(config.urls ? config.urls : [])},
-            ${serialize(config.database || '')},
-            authOptions
-          ).initialize()
-
-          class Content_ByUrlzz extends AbstractJavaScriptMultiMapIndexCreationTask {
-            constructor() {
-              super();
-
-              this.additionalSources = {"Helper": ${serialize(contentIndex)}}
-
-              ${(config.collections || ['Posts']).map(collection => `this.map("${collection.name}", (doc) => mapDocument(doc));`).join('\n')}
-
-              this.deploymentMode = 'Rolling';
-              this.searchEngineType = 'Lucene';
-            }
-          }
-
-          console.log('Deploying index...');
-          await IndexCreation.createIndexes([new Content_ByUrlzz()], store);
-
-          const bulkInsert = store.bulkInsert();
-
-          ${config.collections?.map(collection => `
-            bulkInsert.store(${serialize(collection)}, 'templates/${collection.name}', { '@collection': 'Templates' });
-          `).join('\n')}
-
-          await bulkInsert.finish();
-
-          export { store };
-        `;
-            }
-        },
-    };
-}