astro-loader-pocketbase 2.8.2-next.3 → 2.9.0-next.1

package/README.md

@@ -309,6 +309,17 @@ const blogLive = defineLiveCollection({
 });
 ```
 
+### Error handling
+
+The live content loader follows Astro's standard error handling conventions for live collections. For more information on how to handle errors in your components, see the [Astro documentation on error handling](https://docs.astro.build/en/reference/experimental-flags/live-content-collections/#error-handling).
+
+| Error                           | When it's returned                                                                                            |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `PocketBaseAuthenticationError` | Authentication or authorization fails (missing credentials or invalid token)                                  |
+| `LiveEntryNotFoundError`        | The requested entry doesn't exist or doesn't match the applied filters                                        |
+| `LiveCollectionValidationError` | The data returned by PocketBase doesn't match the Zod schema or the `updatedField` doesn't contain valid data |
+| `LiveCollectionError`           | Any other error occurs (network errors, invalid filter syntax, PocketBase server errors, etc.)                |
+
 ### Caveats
 
 Live content loaders do not (yet 🤞🏼) support zod schemas and thus schema generation and entry transformation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-loader-pocketbase",
-  "version": "2.8.2-next.3",
+  "version": "2.9.0-next.1",
   "description": "A content loader for Astro that uses the PocketBase API",
   "keywords": [
     "astro",
@@ -29,8 +29,8 @@
   "scripts": {
     "format": "npx prettier . --write --cache",
     "format:check": "npx prettier . --check --cache",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
+    "lint": "oxlint --type-aware",
+    "lint:fix": "oxlint --type-aware --fix",
     "prepare": "husky",
     "test": "vitest run",
     "test:e2e": "vitest run $(find test -name '*.e2e-spec.ts')",
@@ -47,11 +47,12 @@
     "@commitlint/config-conventional": "20.0.0",
     "@types/node": "24.9.1",
     "@vitest/coverage-v8": "3.2.4",
-    "astro": "5.14.8",
+    "astro": "5.15.1",
     "globals": "16.4.0",
     "husky": "9.1.7",
-    "lint-staged": "16.2.5",
+    "lint-staged": "16.2.6",
     "oxlint": "1.24.0",
+    "oxlint-tsgolint": "^0.3.0",
     "prettier": "3.6.2",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "2.5.19",

package/src/index.ts

@@ -2,6 +2,7 @@ import {
   experimentalPocketbaseLiveLoader,
   pocketbaseLoader
 } from "./pocketbase-loader";
+import { PocketBaseAuthenticationError } from "./types/errors";
 import type {
   ExperimentalPocketBaseLiveLoaderCollectionFilter,
   ExperimentalPocketBaseLiveLoaderEntryFilter
@@ -11,7 +12,11 @@ import type {
   PocketBaseLoaderOptions
 } from "./types/pocketbase-loader-options.type";
 
-export { experimentalPocketbaseLiveLoader, pocketbaseLoader };
+export {
+  experimentalPocketbaseLiveLoader,
+  PocketBaseAuthenticationError,
+  pocketbaseLoader
+};
 export type {
   ExperimentalPocketBaseLiveLoaderCollectionFilter,
   ExperimentalPocketBaseLiveLoaderEntryFilter,

package/src/loader/cleanup-entries.ts

@@ -1,4 +1,11 @@
 import type { LoaderContext } from "astro/loaders";
+import { z } from "astro/zod";
+import {
+  pocketBaseErrorResponse,
+  pocketBaseListResponse
+} from "../types/pocketbase-api-response.type";
+import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import { pocketBaseBaseEntry } from "../types/pocketbase-entry.type";
 import type { PocketBaseLoaderBaseOptions } from "../types/pocketbase-loader-options.type";
 
 /**
@@ -67,10 +74,10 @@ export async function cleanupEntries(
           );
         }
       } else {
-        const reason = await collectionRequest
-          .json()
-          .then((data) => data.message);
-        const errorMessage = `Fetching ids failed with status code ${collectionRequest.status}.\nReason: ${reason}`;
+        const errorResponse = pocketBaseErrorResponse.parse(
+          await collectionRequest.json()
+        );
+        const errorMessage = `Fetching ids failed with status code ${collectionRequest.status}.\nReason: ${errorResponse.message}`;
         context.logger.error(errorMessage);
       }
 
@@ -81,7 +88,9 @@ export async function cleanupEntries(
     }
 
     // Get the data from the response
-    const response = await collectionRequest.json();
+    const response = cleanUpEntriesResponse.parse(
+      await collectionRequest.json()
+    );
 
     // Add the ids to the set
     for (const item of response.items) {
@@ -97,7 +106,10 @@ export async function cleanupEntries(
 
   // Create a mapping from PocketBase IDs to store keys for proper cleanup
   const storedIds = new Map<string, string>(
-    context.store.values().map((entry) => [entry.data.id as string, entry.id])
+    context.store
+      .values()
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      .map((entry) => [(entry.data as PocketBaseEntry).id, entry.id])
   );
 
   // Check which PocketBase IDs are missing from the server response
@@ -114,3 +126,12 @@ export async function cleanupEntries(
     context.logger.info(`Cleaned up ${cleanedUp} old entries.`);
   }
 }
+
+/**
+ * The response schema for cleaning up entries.
+ */
+const cleanUpEntriesResponse = pocketBaseListResponse
+  .omit({ items: true })
+  .extend({
+    items: z.array(pocketBaseBaseEntry.pick({ id: true }))
+  });

package/src/loader/fetch-collection.ts

@@ -1,3 +1,12 @@
+import {
+  LiveCollectionError,
+  LiveEntryNotFoundError
+} from "astro/content/runtime";
+import { PocketBaseAuthenticationError } from "../types/errors";
+import {
+  pocketBaseErrorResponse,
+  pocketBaseListResponse
+} from "../types/pocketbase-api-response.type";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
 import type { ExperimentalPocketBaseLiveLoaderCollectionFilter } from "../types/pocketbase-live-loader-filter.type";
 import type { PocketBaseLoaderBaseOptions } from "../types/pocketbase-loader-options.type";
@@ -68,27 +77,42 @@ export async function fetchCollection<TEntry extends PocketBaseEntry>(
           options.superuserCredentials &&
           "impersonateToken" in options.superuserCredentials
         ) {
-          throw new Error("The given impersonate token is not valid.");
+          throw new PocketBaseAuthenticationError(
+            options.collectionName,
+            "The given impersonate token is not valid."
+          );
         } else {
-          throw new Error(
+          throw new PocketBaseAuthenticationError(
+            options.collectionName,
             "The collection is not accessible without superuser rights. Please provide superuser credentials in the config."
           );
         }
       }
 
+      if (collectionRequest.status === 404) {
+        throw new LiveEntryNotFoundError(options.collectionName, {
+          ...collectionFilter
+        });
+      }
+
       // Get the reason for the error
-      const reason = await collectionRequest
-        .json()
-        .then((data) => data.message);
-      const errorMessage = `Fetching data failed with status code ${collectionRequest.status}.\nReason: ${reason}`;
-      throw new Error(errorMessage);
+      const errorResponse = pocketBaseErrorResponse.parse(
+        await collectionRequest.json()
+      );
+      throw new LiveCollectionError(
+        options.collectionName,
+        errorResponse.message
+      );
     }
 
     // Get the data from the response
-    const response = await collectionRequest.json();
+    const response = pocketBaseListResponse.parse(
+      await collectionRequest.json()
+    );
 
     // Return current chunk
-    await chunkLoaded(response.items);
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    await chunkLoaded(response.items as Array<TEntry>);
 
     // Update the page and total pages
     page = response.page;

package/src/loader/fetch-entry.ts

@@ -1,4 +1,11 @@
+import {
+  LiveCollectionError,
+  LiveEntryNotFoundError
+} from "astro/content/runtime";
+import { PocketBaseAuthenticationError } from "../types/errors";
+import { pocketBaseErrorResponse } from "../types/pocketbase-api-response.type";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import { pocketBaseEntry } from "../types/pocketbase-entry.type";
 import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
 import { combineFieldsForRequest } from "../utils/combine-fields-for-request";
 import { formatFields } from "../utils/format-fields";
@@ -43,22 +50,34 @@ export async function fetchEntry<TEntry extends PocketBaseEntry>(
         options.superuserCredentials &&
         "impersonateToken" in options.superuserCredentials
       ) {
-        throw new Error("The given impersonate token is not valid.");
+        throw new PocketBaseAuthenticationError(
+          options.collectionName,
+          "The given impersonate token is not valid."
+        );
       } else {
-        throw new Error(
+        throw new PocketBaseAuthenticationError(
+          options.collectionName,
           "The entry is not accessible without superuser rights. Please provide superuser credentials in the config."
         );
       }
     }
 
+    if (entryRequest.status === 404) {
+      throw new LiveEntryNotFoundError(options.collectionName, id);
+    }
+
     // Get the reason for the error
-    const reason = await entryRequest.json().then((data) => data.message);
-    const errorMessage = `Fetching entry "${id}" from collection "${options.collectionName}" failed.\nReason: ${reason}`;
-    throw new Error(errorMessage);
+    const errorResponse = pocketBaseErrorResponse.parse(
+      await entryRequest.json()
+    );
+    throw new LiveCollectionError(
+      options.collectionName,
+      errorResponse.message
+    );
   }
 
   // Get the data from the response
-  const response = await entryRequest.json();
-
-  return response;
+  const response = pocketBaseEntry.parse(await entryRequest.json());
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  return response as TEntry;
 }

package/src/loader/live-collection-loader.ts

@@ -1,4 +1,5 @@
 import type { LiveDataCollection, LiveDataEntry } from "astro";
+import { LiveCollectionError } from "astro/content/runtime";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
 import type { ExperimentalPocketBaseLiveLoaderCollectionFilter } from "../types/pocketbase-live-loader-filter.type";
 import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
@@ -14,13 +15,12 @@ export async function liveCollectionLoader<TEntry extends PocketBaseEntry>(
     | undefined,
   options: ExperimentalPocketBaseLiveLoaderOptions,
   token: string | undefined
-): Promise<LiveDataCollection<TEntry> | { error: Error }> {
+): Promise<LiveDataCollection<TEntry> | { error: LiveCollectionError }> {
   const entries: Array<LiveDataEntry<TEntry>> = [];
 
   try {
     await fetchCollection<TEntry>(
       options,
-      // oxlint-disable-next-line require-await
       async (chunk) => {
         entries.push(...chunk.map((entry) => parseLiveEntry(entry, options)));
       },
@@ -28,7 +28,23 @@ export async function liveCollectionLoader<TEntry extends PocketBaseEntry>(
       collectionFilter
     );
   } catch (error) {
-    return { error: error as Error };
+    if (error instanceof LiveCollectionError) {
+      return { error };
+    }
+
+    if (error instanceof Error) {
+      return {
+        error: new LiveCollectionError(
+          options.collectionName,
+          error.message,
+          error
+        )
+      };
+    }
+
+    return {
+      error: new LiveCollectionError(options.collectionName, String(error))
+    };
   }
 
   return {

package/src/loader/live-entry-loader.ts

@@ -1,4 +1,5 @@
 import type { LiveDataEntry } from "astro";
+import { LiveCollectionError } from "astro/content/runtime";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
 import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
 import { fetchEntry } from "./fetch-entry";
@@ -11,11 +12,27 @@ export async function liveEntryLoader<TEntry extends PocketBaseEntry>(
   id: string,
   options: ExperimentalPocketBaseLiveLoaderOptions,
   token: string | undefined
-): Promise<LiveDataEntry<TEntry> | { error: Error }> {
+): Promise<LiveDataEntry<TEntry> | { error: LiveCollectionError }> {
   try {
     const entry = await fetchEntry<TEntry>(id, options, token);
     return parseLiveEntry(entry, options);
   } catch (error) {
-    return { error: error as Error };
+    if (error instanceof LiveCollectionError) {
+      return { error };
+    }
+
+    if (error instanceof Error) {
+      return {
+        error: new LiveCollectionError(
+          options.collectionName,
+          error.message,
+          error
+        )
+      };
+    }
+
+    return {
+      error: new LiveCollectionError(options.collectionName, String(error))
+    };
   }
 }

package/src/loader/parse-live-entry.ts

@@ -1,4 +1,6 @@
 import type { LiveDataEntry } from "astro";
+import { LiveCollectionValidationError } from "astro/content/runtime";
+import { z } from "astro/zod";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
 import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
 
@@ -17,18 +19,15 @@ export function parseLiveEntry<TEntry extends PocketBaseEntry>(
   // use it as the last modified date cache hint
   if (options.updatedField && entry[options.updatedField]) {
     const value = `${entry[options.updatedField]}`;
-    try {
-      const date = new Date(value);
-      if (isNaN(date.getTime())) {
-        throw new TypeError("Invalid date");
-      }
-
-      lastModified = date;
-    } catch {
-      console.warn(
-        `Entry ${entry.id} of collection ${options.collectionName} has an invalid date in ${options.updatedField}: ${value}`
+    const date = z.coerce.date().safeParse(value);
+    if (!date.success) {
+      throw new LiveCollectionValidationError(
+        options.collectionName,
+        entry.id,
+        date.error
       );
     }
+    lastModified = date.data;
   }
 
   if (!options.contentFields) {

package/src/pocketbase-loader.ts

@@ -1,4 +1,5 @@
 import type { LiveDataCollection, LiveDataEntry } from "astro";
+import type { LiveCollectionError } from "astro/content/runtime";
 import type { LiveLoader, Loader } from "astro/loaders";
 import type { ZodSchema } from "astro/zod";
 import { liveCollectionLoader } from "./loader/live-collection-loader";
@@ -45,7 +46,7 @@ export function pocketbaseLoader(options: PocketBaseLoaderOptions): Loader {
       const token = await tokenPromise;
 
       // Generate the schema for the collection according to the API
-      return await generateSchema(options, token);
+      return generateSchema(options, token);
     }
   };
 }
@@ -65,7 +66,8 @@ export function experimentalPocketbaseLiveLoader<
 ): LiveLoader<
   TEntry,
   ExperimentalPocketBaseLiveLoaderEntryFilter,
-  ExperimentalPocketBaseLiveLoaderCollectionFilter
+  ExperimentalPocketBaseLiveLoaderCollectionFilter,
+  LiveCollectionError
 > {
   // Create shared promise for the superuser token, which can be reused
   const tokenPromise = createTokenPromise(options);
@@ -74,19 +76,21 @@ export function experimentalPocketbaseLiveLoader<
     name: "pocketbase-live-loader",
     loadCollection: async ({
       filter
-    }): Promise<LiveDataCollection<TEntry> | { error: Error }> => {
+    }): Promise<
+      LiveDataCollection<TEntry> | { error: LiveCollectionError }
+    > => {
       const token = await tokenPromise;
 
       // Load entries from the collection
-      return await liveCollectionLoader(filter, options, token);
+      return liveCollectionLoader<TEntry>(filter, options, token);
     },
     loadEntry: async ({
       filter
-    }): Promise<LiveDataEntry<TEntry> | { error: Error }> => {
+    }): Promise<LiveDataEntry<TEntry> | { error: LiveCollectionError }> => {
       const token = await tokenPromise;
 
       // Load a single entry from the collection
-      return await liveEntryLoader(filter.id, options, token);
+      return liveEntryLoader<TEntry>(filter.id, options, token);
     }
   };
 }

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

@@ -1,5 +1,7 @@
+import { pocketBaseErrorResponse } from "../types/pocketbase-api-response.type";
 import type { PocketBaseLoaderOptions } from "../types/pocketbase-loader-options.type";
 import type { PocketBaseCollection } from "../types/pocketbase-schema.type";
+import { pocketBaseCollection } from "../types/pocketbase-schema.type";
 
 /**
  * Fetches the schema for the specified collection from the PocketBase instance.
@@ -26,13 +28,16 @@ export async function getRemoteSchema(
 
   // If the request was not successful, try another method
   if (!schemaRequest.ok) {
-    const reason = await schemaRequest.json().then((data) => data.message);
-    const errorMessage = `Fetching schema from ${options.collectionName} failed with status code ${schemaRequest.status}.\nReason: ${reason}`;
+    const errorResponse = pocketBaseErrorResponse.parse(
+      await schemaRequest.json()
+    );
+    const errorMessage = `Fetching schema from ${options.collectionName} failed with status code ${schemaRequest.status}.\nReason: ${errorResponse.message}`;
     console.error(errorMessage);
 
     return undefined;
   }
 
   // Get the schema from the response
-  return await schemaRequest.json();
+  const response = pocketBaseCollection.parse(await schemaRequest.json());
+  return response;
 }

package/src/schema/parse-schema.ts

@@ -46,6 +46,7 @@ export function parseSchema(
     let fieldType;
 
     // Determine the field type and create the corresponding Zod type
+    // oxlint-disable-next-line switch-exhaustiveness-check
     switch (field.type) {
       case "number":
         fieldType = z.number();
@@ -77,6 +78,7 @@ export function parseSchema(
         }
 
         // Create an enum for the select values
+        // oxlint-disable-next-line no-unsafe-type-assertion
         const values = z.enum(field.values as [string, ...Array<string>]);
 
         // Parse the field type based on the number of values it can have

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

@@ -1,6 +1,7 @@
 import fs from "fs/promises";
 import path from "path";
 import type { PocketBaseCollection } from "../types/pocketbase-schema.type";
+import { pocketBaseDatabase } from "../types/pocketbase-schema.type";
 
 /**
  * Reads the local PocketBase schema file and returns the schema for the specified collection.
@@ -17,15 +18,15 @@ export async function readLocalSchema(
   try {
     // Read the schema file
     const schemaFile = await fs.readFile(realPath, "utf-8");
-    const database: Array<PocketBaseCollection> = JSON.parse(schemaFile);
+    const fileContent = pocketBaseDatabase.safeParse(JSON.parse(schemaFile));
 
     // Check if the database file is valid
-    if (!database || !Array.isArray(database)) {
+    if (!fileContent.success) {
       throw new Error("Invalid schema file");
     }
 
     // Find and return the schema for the collection
-    const schema = database.find(
+    const schema = fileContent.data.find(
       (collection) => collection.name === collectionName
     );
 

package/src/schema/transform-files.ts

@@ -1,3 +1,4 @@
+import { z } from "astro/zod";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
 import type { PocketBaseSchemaEntry } from "../types/pocketbase-schema.type";
 
@@ -18,7 +19,7 @@ export function transformFiles(
     const fieldName = field.name;
 
     if (field.maxSelect === 1) {
-      const fileName = entry[fieldName] as string | undefined;
+      const fileName = z.optional(z.string()).parse(entry[fieldName]);
       // Check if a file name is present
       if (!fileName) {
         continue;
@@ -32,7 +33,7 @@ export function transformFiles(
         fileName
       );
     } else {
-      const fileNames = entry[fieldName] as Array<string> | undefined;
+      const fileNames = z.optional(z.array(z.string())).parse(entry[fieldName]);
       // Check if file names are present
       if (!fileNames) {
         continue;

package/src/types/errors.ts

@@ -0,0 +1,19 @@
+import { LiveCollectionError } from "astro/content/runtime";
+
+/**
+ * Error thrown when there is an authentication issue with PocketBase.
+ */
+export class PocketBaseAuthenticationError extends LiveCollectionError {
+  constructor(collection: string, message: string) {
+    super(collection, message);
+    this.name = "PocketBaseAuthenticationError";
+  }
+
+  static is(error: unknown): error is PocketBaseAuthenticationError {
+    // This is similar to the original implementation in Astro itself.
+    return (
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      !!error && (error as Error)?.name === "PocketBaseAuthenticationError"
+    );
+  }
+}

package/src/types/pocketbase-api-response.type.ts

@@ -0,0 +1,40 @@
+import { z } from "astro/zod";
+import { pocketBaseEntry } from "./pocketbase-entry.type";
+
+/**
+ * The schema for a PocketBase error response.
+ */
+export const pocketBaseErrorResponse = z.object({
+  /**
+   * The error message returned by PocketBase.
+   */
+  message: z.string()
+});
+
+/**
+ * The schema for a PocketBase list response.
+ */
+export const pocketBaseListResponse = z.object({
+  /**
+   * Current page number.
+   */
+  page: z.number(),
+  /**
+   * Total number of pages available.
+   */
+  totalPages: z.number(),
+  /**
+   * Array of items in the current page.
+   */
+  items: z.array(pocketBaseEntry)
+});
+
+/**
+ * The schema for a PocketBase login response.
+ */
+export const pocketBaseLoginResponse = z.object({
+  /**
+   * The authentication token returned by PocketBase.
+   */
+  token: z.string()
+});

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

@@ -1,22 +1,34 @@
+import { z } from "astro/zod";
+
 /**
- * Base interface for all PocketBase entries.
+ * Base schema for all PocketBase entries.
  */
-interface PocketBaseBaseEntry {
+export const pocketBaseBaseEntry = z.object({
   /**
    * ID of the entry.
    */
-  id: string;
+  id: z.string(),
   /**
    * ID of the collection the entry belongs to.
    */
-  collectionId: string;
+  collectionId: z.string(),
   /**
    * Name of the collection the entry belongs to.
    */
-  collectionName: string;
-}
+  collectionName: z.string()
+});
+
+/**
+ * Base interface for all PocketBase entries.
+ */
+export type PocketBaseBaseEntry = z.infer<typeof pocketBaseBaseEntry>;
+
+/**
+ * Schema for a PocketBase entry.
+ */
+export const pocketBaseEntry = pocketBaseBaseEntry.passthrough();
 
 /**
  * Type for a PocketBase entry.
  */
-export type PocketBaseEntry = PocketBaseBaseEntry & Record<string, unknown>;
+export type PocketBaseEntry = z.infer<typeof pocketBaseEntry>;

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

@@ -1,60 +1,92 @@
+import { z } from "astro/zod";
+
 /**
  * Entry for a collections schema in PocketBase.
  */
-export interface PocketBaseSchemaEntry {
+export const pocketBaseSchemaEntry = z.object({
   /**
    * Flag to indicate if the field is hidden.
    * Hidden fields are not returned in the API response.
    */
-  hidden: boolean;
+  hidden: z.optional(z.boolean()),
   /**
    * Name of the field.
    */
-  name: string;
+  name: z.string(),
   /**
    * Type of the field.
    */
-  type: string;
+  type: z.enum([
+    "text",
+    "editor",
+    "number",
+    "bool",
+    "email",
+    "url",
+    "date",
+    "autodate",
+    "select",
+    "file",
+    "relation",
+    "json",
+    "geoPoint",
+    "password"
+  ]),
   /**
    * Whether the field is required.
    */
-  required: boolean;
+  required: z.optional(z.boolean()),
   /**
    * Values for a select field.
    * This is only present if the field type is "select".
    */
-  values?: Array<string>;
+  values: z.optional(z.array(z.string())),
   /**
    * Maximum number of values for a select field.
    * This is only present on "select", "relation", and "file" fields.
    */
-  maxSelect?: number;
+  maxSelect: z.optional(z.number()),
   /**
    * Whether the field is filled when the entry is created.
    * This is only present on "autodate" fields.
    */
-  onCreate?: boolean;
+  onCreate: z.optional(z.boolean()),
   /**
    * Whether the field is updated when the entry is updated.
    * This is only present on "autodate" fields.
    */
-  onUpdate?: boolean;
-}
+  onUpdate: z.optional(z.boolean())
+});
+
+/**
+ * Entry for a collections schema in PocketBase.
+ */
+export type PocketBaseSchemaEntry = z.infer<typeof pocketBaseSchemaEntry>;
 
 /**
  * Schema for a PocketBase collection.
  */
-export interface PocketBaseCollection {
+export const pocketBaseCollection = z.object({
   /**
    * Name of the collection.
    */
-  name: string;
+  name: z.string(),
   /**
    * Type of the collection.
    */
-  type: "base" | "view" | "auth";
+  type: z.enum(["base", "view", "auth"]),
   /**
    * Schema of the collection.
    */
-  fields: Array<PocketBaseSchemaEntry>;
-}
+  fields: z.array(pocketBaseSchemaEntry)
+});
+
+/**
+ * Type for a PocketBase collection.
+ */
+export type PocketBaseCollection = z.infer<typeof pocketBaseCollection>;
+
+/**
+ * Schema for an entire PocketBase database.
+ */
+export const pocketBaseDatabase = z.array(pocketBaseCollection);

package/src/utils/get-superuser-token.ts

@@ -1,4 +1,8 @@
 import type { AstroIntegrationLogger } from "astro";
+import {
+  pocketBaseErrorResponse,
+  pocketBaseLoginResponse
+} from "../types/pocketbase-api-response.type";
 
 /**
  * This function will get a superuser token from the given PocketBase instance.
@@ -52,8 +56,10 @@ export async function getSuperuserToken(
       return getSuperuserToken(url, superuserCredentials, logger);
     }
 
-    const reason = await loginRequest.json().then((data) => data.message);
-    const errorMessage = `The given email / password for ${url} was not correct. Astro can't generate type definitions automatically and may not have access to all resources.\nReason: ${reason}`;
+    const errorResponse = pocketBaseErrorResponse.parse(
+      await loginRequest.json()
+    );
+    const errorMessage = `The given email / password for ${url} was not correct. Astro can't generate type definitions automatically and may not have access to all resources.\nReason: ${errorResponse.message}`;
     if (logger) {
       logger.error(errorMessage);
     } else {
@@ -63,5 +69,6 @@ export async function getSuperuserToken(
   }
 
   // Return the token
-  return await loginRequest.json().then((data) => data.token);
+  const response = pocketBaseLoginResponse.parse(await loginRequest.json());
+  return response.token;
 }