@strifeapp/astro 1.0.4 → 1.0.5

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,309 +1,39 @@
-import { loadEnv as f } from "/Users/marcus/Library/Mobile Documents/com~apple~CloudDocs/Projects.nosync/ideas/astro-strife/node_modules/vite/dist/node/index.js";
-import r from "/Users/marcus/Library/Mobile Documents/com~apple~CloudDocs/Projects.nosync/ideas/astro-strife/node_modules/serialize-javascript/index.js";
-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", s = "\0" + d;
-function h(e) {
-  return {
-    name: "strife:store",
-    resolveId(n) {
-      if (n === d)
-        return s;
-    },
-    load(n) {
-      var t;
-      if (n === s)
-        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(
-          (o) => `this.map("${o.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((o) => `
-            bulkInsert.store(${r(o)}, 'templates/${o.name}', { '@collection': 'Templates' });
-          `).join(`
-`)}
-
-          await bulkInsert.finish();
-
-          export { store };
-        `;
-    }
-  };
-}
-const v = {
-  type: "pfx"
+import { loadEnv } from "vite";
+// Import the vite plugin directly from the file
+import { vitePluginStrifeStore } from './vite-plugin-strife-store.js';
+const defaultClientConfig = {
+    type: 'pfx',
 };
-function A(e = {}) {
-  let n, t;
-  return {
-    name: "@strife/astro",
-    hooks: {
-      "astro:config:setup": ({ command: o, config: i, updateConfig: l }) => {
-        var a;
-        n = o, t = f(n, i.vite.envDir ?? "", "");
-        const c = {
-          urls: (a = t.STRIFE_DATABASE_URLS) == null ? void 0 : a.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 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)
+                        ],
+                    }
+                });
+            },
+        }
+    };
 }
-export {
-  A as default
-};

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

@@ -0,0 +1 @@
+export * from './vite-plugin-strife-store';

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

@@ -0,0 +1,2 @@
+// 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.d.ts

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

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

@@ -0,0 +1,59 @@
+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 };
+        `;
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strifeapp/astro",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Official Strife Astro integration",
   "keywords": [
     "astro-integration",
@@ -11,7 +11,8 @@
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "vite build"
+    "build": "vite build && tsc",
+    "prepublishOnly": "npm run build"
   },
   "exports": {
     ".": "./dist/index.js",
@@ -30,7 +31,8 @@
   "devDependencies": {
     "@types/dotenv": "^8.2.0",
     "typescript": "^5.7.3",
-    "vite": "^6.2.1"
+    "vite": "^6.2.1",
+    "vite-plugin-dts": "^4.5.3"
   },
   "peerDependencies": {
     "astro": "^4.0.0 || ^5.0.0",