astro-loader-pocketbase 0.3.0-rc.1 → 0.3.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-loader-pocketbase",
-  "version": "0.3.0-rc.1",
+  "version": "0.3.0-rc.3",
   "description": "A content loader for Astro that uses the PocketBase API",
   "license": "MIT",
   "author": "Luis Wolf <development@pawcode.de> (https://pawcode.de)",
@@ -23,8 +23,8 @@
   "devDependencies": {
     "@eslint/js": "^9.11.1",
     "@stylistic/eslint-plugin": "^2.8.0",
-    "@types/node": "^22.5.5",
-    "astro": "^5.0.0-beta.1",
+    "@types/node": "^22.7.4",
+    "astro": "^5.0.0-beta.2",
     "eslint": "^9.11.1",
     "globals": "^15.9.0",
     "husky": "^9.1.6",

package/src/generate-schema.ts

@@ -5,6 +5,7 @@ import type { PocketBaseCollection } from "./types/pocketbase-schema.type";
 import { getRemoteSchema } from "./utils/get-remote-schema";
 import { parseSchema } from "./utils/parse-schema";
 import { readLocalSchema } from "./utils/read-local-schema";
+import { transformFiles } from "./utils/transform-files";
 
 /**
  * Basic schema for every PocketBase collection.
@@ -84,8 +85,21 @@ export async function generateSchema(
   const base = collection.type === "view" ? VIEW_SCHEMA : BASIC_SCHEMA;
 
   // Combine the basic schema with the parsed fields
-  return z.object({
+  const schema = z.object({
     ...base,
     ...fields
   });
+
+  // Get all file fields
+  const fileFields = collection.schema.filter((field) => field.type === "file");
+
+  if (fileFields.length === 0) {
+    return schema;
+  }
+
+  // Transform file names to file urls
+  return schema.transform((entry) =>
+    // @ts-expect-error - `updated` and `created` are already transformed to dates
+    transformFiles(options.url, fileFields, entry)
+  );
 }

package/src/load-entries.ts

@@ -43,7 +43,7 @@ export async function loadEntries(
   let page = 1;
   let totalPages = 0;
   let entries = 0;
-  let hasUpdatedColumn = false;
+  let hasUpdatedColumn = !!lastModified;
 
   // Fetch all (modified) entries
   do {

package/src/pocketbase-loader.ts

@@ -1,4 +1,5 @@
 import type { Loader, LoaderContext } from "astro/loaders";
+import packageJson from "./../package.json";
 import { cleanupEntries } from "./cleanup-entries";
 import { generateSchema } from "./generate-schema";
 import { loadEntries } from "./load-entries";
@@ -14,6 +15,16 @@ export function pocketbaseLoader(options: PocketBaseLoaderOptions): Loader {
   return {
     name: "pocketbase-loader",
     load: async (context: LoaderContext): Promise<void> => {
+      // Check if the version has changed to force an update
+      const lastVersion = context.meta.get("version");
+      if (lastVersion !== packageJson.version) {
+        context.logger.info(
+          `PocketBase loader was updated from ${lastVersion} to ${packageJson.version}. All entries will be loaded again.`
+        );
+
+        options.forceUpdate = true;
+      }
+
       // Get the date of the last fetch to only update changed entries.
       // If `forceUpdate` is set to `true`, this will be `undefined` to fetch all entries again.
       const lastModified = options.forceUpdate
@@ -67,6 +78,8 @@ export function pocketbaseLoader(options: PocketBaseLoaderOptions): Loader {
 
       // Set the last modified date to the current date
       context.meta.set("last-modified", new Date().toISOString());
+
+      context.meta.set("version", packageJson.version);
     },
     schema: async () => {
       // Generate the schema for the collection according to the API

package/src/types/pocketbase-loader-options.type.ts

@@ -19,7 +19,7 @@ export interface PocketBaseLoaderOptions {
    * The loader will concatenate the content of all fields in the order they are defined in the array.
    * Each block will be contained in a `<section>` element.
    */
-  content: string | Array<string>;
+  content?: string | Array<string>;
   /**
    * Email of an admin to get full access to the PocketBase instance.
    * Together with `adminPassword` this is required to get automatic type generation and to access all resources even if they are not public.

package/src/utils/parse-entry.ts

@@ -12,7 +12,7 @@ import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
 export async function parseEntry(
   entry: PocketBaseEntry,
   { generateDigest, parseData, store }: LoaderContext,
-  contentFields: string | Array<string>
+  contentFields?: string | Array<string>
 ): Promise<void> {
   // Parse the data to match the schema
   // This will throw an error if the data does not match the schema
@@ -27,6 +27,16 @@ export async function parseEntry(
   // View collections don't necessarily publish the updated date, so the whole entry is used for the digest.
   const digest = generateDigest(entry.updated ?? entry.created ?? entry);
 
+  if (!contentFields) {
+    // Store the entry
+    store.set({
+      id: entry.id,
+      data,
+      digest
+    });
+    return;
+  }
+
   // Generate the content for the entry
   let content: string;
   if (typeof contentFields === "string") {

package/src/utils/parse-schema.ts

@@ -44,7 +44,8 @@ export function parseSchema(
         break;
       case "relation":
       case "file":
-        // NOTE: Relations and files are currently not supported and are treated as strings
+        // NOTE: Relations are currently not supported and are treated as strings
+        // NOTE: Files are later transformed to URLs
 
         // Parse the field type based on the number of values it can have
         fieldType = parseSingleOrMultipleValues(field, z.string());

package/src/utils/transform-files.ts

@@ -0,0 +1,66 @@
+import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import type { PocketBaseSchemaEntry } from "../types/pocketbase-schema.type";
+
+/**
+ * Transforms file names in a PocketBase entry to file URLs.
+ *
+ * @param baseUrl URL of the PocketBase instance.
+ * @param collection Collection of the entry.
+ * @param entry Entry to transform.
+ */
+export function transformFiles(
+  baseUrl: string,
+  fileFields: Array<PocketBaseSchemaEntry>,
+  entry: PocketBaseEntry
+): PocketBaseEntry {
+  // Transform all file names to file URLs
+  for (const field of fileFields) {
+    const fieldName = field.name;
+
+    if (field.options.maxSelect === 1) {
+      const fileName = entry[fieldName] as string | undefined;
+      // Check if a file name is present
+      if (!fileName) {
+        continue;
+      }
+
+      // Transform the file name to a file URL
+      entry[fieldName] = transformFileUrl(
+        baseUrl,
+        entry.collectionName,
+        entry.id,
+        fileName
+      );
+    } else {
+      const fileNames = entry[fieldName] as Array<string> | undefined;
+      // Check if file names are present
+      if (!fileNames) {
+        continue;
+      }
+
+      // Transform all file names to file URLs
+      entry[fieldName] = fileNames.map((file) =>
+        transformFileUrl(baseUrl, entry.collectionName, entry.id, file)
+      );
+    }
+  }
+
+  return entry;
+}
+
+/**
+ * Transforms a file name to a PocketBase file URL.
+ *
+ * @param base Base URL of the PocketBase instance.
+ * @param collectionName Name of the collection.
+ * @param entryId ID of the entry.
+ * @param file Name of the file.
+ */
+function transformFileUrl(
+  base: string,
+  collectionName: string,
+  entryId: string,
+  file: string
+): string {
+  return `${base}/api/files/${collectionName}/${entryId}/${file}`;
+}