astro-loader-pocketbase 0.2.0 → 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 pawcode Development
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,4 +1,10 @@
-# astro-pocketbase-loader
+# astro-loader-pocketbase
+
+<!-- ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/pawcoding/astro-loader-pocketbase/release.yaml?style=flat-square) -->
+[![NPM Version](https://img.shields.io/npm/v/astro-loader-pocketbase?style=flat-square)](https://www.npmjs.com/package/astro-loader-pocketbase)
+[![NPM Downloads](https://img.shields.io/npm/dw/astro-loader-pocketbase?style=flat-square)](https://www.npmjs.com/package/astro-loader-pocketbase)
+[![GitHub License](https://img.shields.io/github/license/pawcoding/astro-loader-pocketbase?style=flat-square)](https://github.com/pawcoding/astro-loader-pocketbase/blob/master/LICENSE)
+[![Discord](https://img.shields.io/discord/484669557747875862?style=flat-square&label=Discord)](https://discord.gg/GzgTh4hxrx)
 
 This package is a simple loader to load data from a PocketBase database into Astro using the [Astro Loader API](https://5-0-0-beta.docs.astro.build/en/reference/loader-reference/) introduced in Astro 5.
 

package/package.json

@@ -1,36 +1,41 @@
 {
   "name": "astro-loader-pocketbase",
+  "version": "0.2.2",
   "description": "A content loader for Astro that uses the PocketBase API",
+  "license": "MIT",
+  "author": "Luis Wolf <development@pawcode.de> (https://pawcode.de)",
   "homepage": "https://github.com/pawcoding/astro-loader-pocketbase",
-  "version": "0.2.0",
   "type": "module",
   "exports": {
     ".": "./index.ts"
   },
   "files": [
-    "src",
-    "index.ts"
+    "index.ts",
+    "src"
   ],
-  "author": {
-    "name": "Luis Wolf",
-    "email": "development@pawcode.de",
-    "url": "https://pawcode.de"
+  "scripts": {
+    "lint": "npx eslint",
+    "prepare": "husky"
+  },
+  "peerDependencies": {
+    "astro": "^5.0.0"
   },
-  "keywords": [
-    "withastro",
-    "astro",
-    "astro-loader",
-    "astro-content-loader",
-    "pocketbase"
-  ],
-  "scripts": {},
   "devDependencies": {
+    "@eslint/js": "^9.11.1",
+    "@stylistic/eslint-plugin": "^2.8.0",
     "@types/node": "^22.5.5",
     "astro": "^5.0.0-beta.1",
-    "typescript": "^5.6.2"
+    "eslint": "^9.11.1",
+    "globals": "^15.9.0",
+    "husky": "^9.1.6",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.7.0"
   },
-  "peerDependencies": {
-    "astro": "^5.0.0"
-  },
-  "license": "MIT"
+  "keywords": [
+    "astro",
+    "astro-content-loader",
+    "astro-loader",
+    "pocketbase",
+    "withastro"
+  ]
 }

package/src/generate-schema.ts

@@ -1,6 +1,7 @@
 import type { ZodSchema } from "astro/zod";
 import { z } from "astro/zod";
 import type { PocketBaseLoaderOptions } from "./types/pocketbase-loader-options.type";
+import type { PocketBaseSchemaEntry } 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";
@@ -25,7 +26,7 @@ const BASIC_SCHEMA = {
 export async function generateSchema(
   options: PocketBaseLoaderOptions
 ): Promise<ZodSchema> {
-  let schema: Array<Record<string, any>> | undefined;
+  let schema: Array<PocketBaseSchemaEntry> | undefined;
 
   // Try to get the schema directly from the PocketBase instance
   schema = await getRemoteSchema(options);

package/src/types/pocketbase-base.type.ts

@@ -0,0 +1,30 @@
+/**
+ * Base interface for all PocketBase entries.
+ */
+interface PocketBaseBaseEntry {
+  /**
+   * ID of the entry.
+   */
+  id: string;
+  /**
+   * ID of the collection the entry belongs to.
+   */
+  collectionId: string;
+  /**
+   * Name of the collection the entry belongs to.
+   */
+  collectionName: string;
+  /**
+   * Date the entry was created.
+   */
+  created: string;
+  /**
+   * Date the entry was last updated.
+   */
+  updated: string;
+}
+
+/**
+ * Type for a PocketBase entry.
+ */
+export type PocketBaseEntry = PocketBaseBaseEntry & Record<string, unknown>;

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

@@ -1,7 +1,7 @@
 /**
  * Options for the PocketBase loader.
  */
-export type PocketBaseLoaderOptions = {
+export interface PocketBaseLoaderOptions {
   /**
    * URL of the PocketBase instance.
    */
@@ -41,4 +41,4 @@ export type PocketBaseLoaderOptions = {
    * If you want to fetch all entries, set this to `true`.
    */
   forceUpdate?: boolean;
-};
+}

package/src/types/pocketbase-schema.type.ts

@@ -0,0 +1,46 @@
+/**
+ * Entry for a collections schema in PocketBase.
+ */
+export interface PocketBaseSchemaEntry {
+  /**
+   * Name of the field.
+   */
+  name: string;
+  /**
+   * Type of the field.
+   */
+  type: string;
+  /**
+   * Whether the field is required.
+   */
+  required: boolean;
+  /**
+   * Options for the field.
+   */
+  options: {
+    /**
+     * Values for a select field.
+     * This is only present if the field type is "select".
+     */
+    values?: Array<string>;
+    /**
+     * Maximum number of values for a select field.
+     * This is only present on "select", "relation", and "file" fields.
+     */
+    maxSelect?: number;
+  };
+}
+
+/**
+ * Schema for a PocketBase collection.
+ */
+export interface PocketBaseCollection {
+  /**
+   * Name of the collection.
+   */
+  name: string;
+  /**
+   * Schema of the collection.
+   */
+  schema: Array<PocketBaseSchemaEntry>;
+}

package/src/utils/get-remote-schema.ts

@@ -1,4 +1,8 @@
 import type { PocketBaseLoaderOptions } from "../types/pocketbase-loader-options.type";
+import type {
+  PocketBaseCollection,
+  PocketBaseSchemaEntry
+} from "../types/pocketbase-schema.type";
 import { getAdminToken } from "./get-admin-token";
 
 /**
@@ -8,7 +12,7 @@ import { getAdminToken } from "./get-admin-token";
  */
 export async function getRemoteSchema(
   options: PocketBaseLoaderOptions
-): Promise<Array<Record<string, any>> | undefined> {
+): Promise<Array<PocketBaseSchemaEntry> | undefined> {
   if (!options.adminEmail || !options.adminPassword) {
     return undefined;
   }
@@ -48,6 +52,6 @@ export async function getRemoteSchema(
   }
 
   // Get the schema from the response
-  const schema = await schemaRequest.json();
+  const schema: PocketBaseCollection = await schemaRequest.json();
   return schema.schema;
 }

package/src/utils/parse-entry.ts

@@ -1,4 +1,5 @@
 import type { LoaderContext } from "astro/loaders";
+import type { PocketBaseEntry } from "../types/pocketbase-base.type";
 
 /**
  * Parse an entry from PocketBase to match the schema and store it in the store.
@@ -9,7 +10,7 @@ import type { LoaderContext } from "astro/loaders";
  *                      If multiple fields are used, they will be concatenated and wrapped in `<section>` elements.
  */
 export async function parseEntry(
-  entry: Record<string, any>,
+  entry: PocketBaseEntry,
   { generateDigest, parseData, store }: LoaderContext,
   contentFields: string | Array<string>
 ): Promise<void> {
@@ -28,7 +29,7 @@ export async function parseEntry(
   let content: string;
   if (typeof contentFields === "string") {
     // Only one field is used as content
-    content = entry[contentFields];
+    content = `${entry[contentFields]}`;
   } else {
     // Multiple fields are used as content, wrap each block in a section and concatenate them
     content = contentFields

package/src/utils/parse-schema.ts

@@ -1,7 +1,8 @@
 import { z } from "astro/zod";
+import type { PocketBaseSchemaEntry } from "../types/pocketbase-schema.type";
 
 export function parseSchema(
-  schema: Array<Record<string, any>>
+  schema: Array<PocketBaseSchemaEntry>
 ): Record<string, z.ZodType> {
   // Prepare the schemas fields
   const fields: Record<string, z.ZodType> = {};
@@ -14,29 +15,36 @@ export function parseSchema(
     switch (field.type) {
       case "number":
         // Coerce the value to a number
-        fieldType = z.number({ coerce: true });
+        fieldType = z.coerce.number();
         break;
       case "bool":
         // Coerce the value to a boolean
-        fieldType = z.boolean({ coerce: true });
+        fieldType = z.coerce.boolean();
         break;
       case "date":
         // Coerce and parse the value as a date
-        fieldType = z.date({ coerce: true });
+        fieldType = z.coerce.date();
         break;
       case "select":
+        if (!field.options.values) {
+          throw new Error(
+            `Field ${field.name} is of type "select" but has no values defined.`
+          );
+        }
+
         // Create an enum for the select values
+        // @ts-expect-error - Zod complains because the values are not known at compile time and thus the array is not static.
         const values = z.enum(field.options.values);
 
         // Parse the field type based on the number of values it can have
-        fieldType = parseSingleOrMultipleValues(field as any, values);
+        fieldType = parseSingleOrMultipleValues(field, values);
         break;
       case "relation":
       case "file":
         // NOTE: Relations and files are currently not supported and are treated as strings
 
         // Parse the field type based on the number of values it can have
-        fieldType = parseSingleOrMultipleValues(field as any, z.string());
+        fieldType = parseSingleOrMultipleValues(field, z.string());
         break;
       case "json":
         // Parse the field as an object
@@ -50,7 +58,10 @@ export function parseSchema(
 
     // If the field is not required, mark it as optional
     if (!field.required) {
-      fieldType.isOptional();
+      fieldType = z.preprocess(
+        (val) => val || undefined,
+        z.optional(fieldType)
+      );
     }
 
     // Add the field to the fields object
@@ -69,11 +80,11 @@ export function parseSchema(
  * @returns The parsed field type
  */
 function parseSingleOrMultipleValues(
-  field: { options: { maxSelect: number } },
+  field: PocketBaseSchemaEntry,
   type: z.ZodType
 ) {
   // If the select allows multiple values, create an array of the enum
-  if (field.options.maxSelect === 1) {
+  if (field.options.maxSelect === undefined || field.options.maxSelect === 1) {
     return type;
   } else {
     return z.array(type);

package/src/utils/read-local-schema.ts

@@ -1,5 +1,9 @@
 import fs from "fs/promises";
 import path from "path";
+import type {
+  PocketBaseCollection,
+  PocketBaseSchemaEntry
+} from "../types/pocketbase-schema.type";
 
 /**
  * Reads the local PocketBase schema file and returns the schema for the specified collection.
@@ -10,13 +14,13 @@ import path from "path";
 export async function readLocalSchema(
   localSchemaPath: string,
   collectionName: string
-): Promise<Array<Record<string, any>> | undefined> {
+): Promise<Array<PocketBaseSchemaEntry> | undefined> {
   const realPath = path.join(process.cwd(), localSchemaPath);
 
   try {
     // Read the schema file
     const schemaFile = await fs.readFile(realPath, "utf-8");
-    const database = JSON.parse(schemaFile);
+    const database: Array<PocketBaseCollection> = JSON.parse(schemaFile);
 
     // Check if the database file is valid
     if (!database || !Array.isArray(database)) {
@@ -27,6 +31,13 @@ export async function readLocalSchema(
     const schema = database.find(
       (collection) => collection.name === collectionName
     );
+
+    if (!schema) {
+      throw new Error(
+        `Collection "${collectionName}" not found in schema file`
+      );
+    }
+
     return schema.schema;
   } catch (error) {
     console.error(