astro-loader-pocketbase 2.6.2 → 2.7.0-live-collections.1

package/README.md

@@ -143,12 +143,16 @@ const blog = defineCollection({
     ...options,
     superuserCredentials: {
       email: "<superuser-email>",
-      password: "<superuser-password>"
+      password: "<superuser-password>",
+      // or
+      impersonateToken: "<superuser-impersonate-token>"
     }
   })
 });
 ```
 
+_It's recommended to use an [impersonate token (API token)](https://pocketbase.io/docs/authentication/#api-keys) instead of the email and password, as this is more secure and can be easily revoked._
+
 Under the hood, the loader will use the [PocketBase API](https://pocketbase.io/docs/api-collections/#view-collection) to fetch the schema of your collection and generate types with Zod based on that schema.
 
 ### Local schema
@@ -193,18 +197,18 @@ This will remove `undefined` from the type of these fields and mark them as requ
 
 ## All options
 
-| Option                 | Type                                  | Required | Description                                                                                                     |
-| ---------------------- | ------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------- |
-| `url`                  | `string`                              | x        | The URL of your PocketBase instance.                                                                            |
-| `collectionName`       | `string`                              | x        | The name of the collection in your PocketBase instance.                                                         |
-| `idField`              | `string`                              |          | The field in the collection to use as unique id. Defaults to `id`.                                              |
-| `contentFields`        | `string \| Array<string>`             |          | The field in the collection to use as content. This can also be an array of fields.                             |
-| `updatedField`         | `string`                              |          | The field in the collection that stores the last update date of an entry. This is used for incremental builds.  |
-| `filter`               | `string`                              |          | Custom filter to use when fetching entries. Used to filter the entries by specific conditions.                  |
-| `superuserCredentials` | `{ email: string, password: string }` |          | The email and password of the superuser of the PocketBase instance. This is used for automatic type generation. |
-| `localSchema`          | `string`                              |          | The path to a local schema file. This is used for automatic type generation.                                    |
-| `jsonSchemas`          | `Record<string, z.ZodSchema>`         |          | A record of Zod schemas to use for type generation of `json` fields.                                            |
-| `improveTypes`         | `boolean`                             |          | Whether to improve the types of `number` and `boolean` fields, removing `undefined` from them.                  |
+| Option                 | Type                                                                  | Required | Description                                                                                                                        |
+| ---------------------- | --------------------------------------------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `url`                  | `string`                                                              | x        | The URL of your PocketBase instance.                                                                                               |
+| `collectionName`       | `string`                                                              | x        | The name of the collection in your PocketBase instance.                                                                            |
+| `idField`              | `string`                                                              |          | The field in the collection to use as unique id. Defaults to `id`.                                                                 |
+| `contentFields`        | `string \| Array<string>`                                             |          | The field in the collection to use as content. This can also be an array of fields.                                                |
+| `updatedField`         | `string`                                                              |          | The field in the collection that stores the last update date of an entry. This is used for incremental builds.                     |
+| `filter`               | `string`                                                              |          | Custom filter to use when fetching entries. Used to filter the entries by specific conditions.                                     |
+| `superuserCredentials` | `{ email: string, password: string } \| { impersonateToken: string }` |          | The email and password or impersonate token of a superuser of the PocketBase instance. This is used for automatic type generation. |
+| `localSchema`          | `string`                                                              |          | The path to a local schema file. This is used for automatic type generation.                                                       |
+| `jsonSchemas`          | `Record<string, z.ZodSchema>`                                         |          | A record of Zod schemas to use for type generation of `json` fields.                                                               |
+| `improveTypes`         | `boolean`                                                             |          | Whether to improve the types of `number` and `boolean` fields, removing `undefined` from them.                                     |
 
 ## Special cases
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-loader-pocketbase",
-  "version": "2.6.2",
+  "version": "2.7.0-live-collections.1",
   "description": "A content loader for Astro that uses the PocketBase API",
   "keywords": [
     "astro",
@@ -39,26 +39,27 @@
     "test:e2e:watch": "vitest watch $(find test -name '*.e2e-spec.ts')",
     "test:unit": "vitest run $(find test -name '*.spec.ts')",
     "test:unit:watch": "vitest watch $(find test -name '*.spec.ts')",
-    "test:watch": "vitest watch"
+    "test:watch": "vitest watch",
+    "typecheck": "npx tsc --noEmit"
   },
   "devDependencies": {
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
-    "@eslint/js": "^9.30.0",
-    "@stylistic/eslint-plugin": "^5.0.0",
+    "@eslint/js": "^9.30.1",
+    "@stylistic/eslint-plugin": "^5.1.0",
     "@types/node": "^22.14.1",
     "@vitest/coverage-v8": "^3.2.4",
-    "astro": "^5.10.1",
-    "eslint": "^9.30.0",
+    "astro": "^5.11.0",
+    "eslint": "^9.30.1",
     "eslint-config-prettier": "^10.1.5",
-    "globals": "^16.2.0",
+    "globals": "^16.3.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.2",
     "prettier": "^3.6.2",
     "prettier-plugin-organize-imports": "^4.1.0",
-    "prettier-plugin-packagejson": "^2.5.17",
+    "prettier-plugin-packagejson": "^2.5.18",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.35.0",
+    "typescript-eslint": "^8.35.1",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
@@ -66,7 +67,6 @@
   },
   "packageManager": "npm@11.4.2",
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
   }
 }

package/src/index.ts

@@ -1,5 +1,14 @@
-import { pocketbaseLoader } from "./pocketbase-loader";
-import type { PocketBaseLoaderOptions } from "./types/pocketbase-loader-options.type";
+import {
+  experimentalPocketbaseLiveLoader,
+  pocketbaseLoader
+} from "./pocketbase-loader";
+import type {
+  ExperimentalPocketBaseLiveLoaderOptions,
+  PocketBaseLoaderOptions
+} from "./types/pocketbase-loader-options.type";
 
-export { pocketbaseLoader };
-export type { PocketBaseLoaderOptions };
+export { experimentalPocketbaseLiveLoader, pocketbaseLoader };
+export type {
+  ExperimentalPocketBaseLiveLoaderOptions,
+  PocketBaseLoaderOptions
+};

package/src/loader/cleanup-entries.ts

@@ -56,9 +56,16 @@ export async function cleanupEntries(
     if (!collectionRequest.ok) {
       // If the collection is locked, an superuser token is required
       if (collectionRequest.status === 403) {
-        context.logger.error(
-          `The collection is not accessible without superuser rights. Please provide superuser credentials in the config.`
-        );
+        if (
+          options.superuserCredentials &&
+          "impersonateToken" in options.superuserCredentials
+        ) {
+          context.logger.error("The given impersonate token is not valid.");
+        } else {
+          context.logger.error(
+            "The collection is not accessible without superuser rights. Please provide superuser credentials in the config."
+          );
+        }
       } else {
         const reason = await collectionRequest
           .json()

package/src/loader/fetch-collection.ts

@@ -0,0 +1,99 @@
+import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import type { PocketBaseLoaderOptions } from "../types/pocketbase-loader-options.type";
+
+export async function fetchCollection<TEntry extends PocketBaseEntry>(
+  options: Pick<
+    PocketBaseLoaderOptions,
+    | "collectionName"
+    | "url"
+    | "updatedField"
+    | "filter"
+    | "superuserCredentials"
+  >,
+  chunkLoaded: (entries: Array<TEntry>) => Promise<void>,
+  token: string | undefined,
+  lastModified: string | undefined
+): Promise<void> {
+  // Build the URL for the collections endpoint
+  const collectionUrl = new URL(
+    `api/collections/${options.collectionName}/records`,
+    options.url
+  ).href;
+
+  // Create the headers for the request to append the token (if available)
+  const collectionHeaders = new Headers();
+  if (token) {
+    collectionHeaders.set("Authorization", token);
+  }
+
+  // Prepare pagination variables
+  let page = 0;
+  let totalPages = 0;
+
+  // Fetch all (modified) entries
+  do {
+    // Build search parameters
+    const searchParams = new URLSearchParams({
+      page: `${++page}`,
+      perPage: "100"
+    });
+
+    const filters = [];
+    if (lastModified && options.updatedField) {
+      // If `lastModified` is set, only fetch entries that have been modified since the last fetch
+      filters.push(`(${options.updatedField}>"${lastModified}")`);
+      // Sort by the updated field and id
+      searchParams.set("sort", `-${options.updatedField},id`);
+    }
+    if (options.filter) {
+      filters.push(`(${options.filter})`);
+    }
+
+    // Add filters to search parameters
+    if (filters.length > 0) {
+      searchParams.set("filter", filters.join("&&"));
+    }
+
+    // Fetch entries from the collection
+    const collectionRequest = await fetch(
+      `${collectionUrl}?${searchParams.toString()}`,
+      {
+        headers: collectionHeaders
+      }
+    );
+
+    // If the request was not successful, print the error message and return
+    if (!collectionRequest.ok) {
+      // If the collection is locked, an superuser token is required
+      if (collectionRequest.status === 403) {
+        if (
+          options.superuserCredentials &&
+          "impersonateToken" in options.superuserCredentials
+        ) {
+          throw new Error("The given impersonate token is not valid.");
+        } else {
+          throw new Error(
+            "The collection is not accessible without superuser rights. Please provide superuser credentials in the config."
+          );
+        }
+      }
+
+      // 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);
+    }
+
+    // Get the data from the response
+    const response = await collectionRequest.json();
+
+    // Return current chunk
+    await chunkLoaded(response.items);
+
+    // Update the page and total pages
+    page = response.page;
+    totalPages = response.totalPages;
+  } while (page < totalPages);
+}

package/src/loader/fetch-entry.ts

@@ -0,0 +1,52 @@
+import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+
+export async function fetchEntry<TEntry extends PocketBaseEntry>(
+  id: string,
+  options: ExperimentalPocketBaseLiveLoaderOptions,
+  token: string | undefined
+): Promise<TEntry> {
+  // Build the URL for the entry endpoint
+  const entryUrl = new URL(
+    `api/collections/${options.collectionName}/records/${id}`,
+    options.url
+  ).href;
+
+  // Create the headers for the request to append the token (if available)
+  const entryHeaders = new Headers();
+  if (token) {
+    entryHeaders.set("Authorization", token);
+  }
+
+  // Fetch the entry from the collection
+  const entryRequest = await fetch(entryUrl, {
+    headers: entryHeaders
+  });
+
+  // If the request was not successful, return an error
+  if (!entryRequest.ok) {
+    // If the entry is locked, a superuser token is required
+    if (entryRequest.status === 403) {
+      if (
+        options.superuserCredentials &&
+        "impersonateToken" in options.superuserCredentials
+      ) {
+        throw new Error("The given impersonate token is not valid.");
+      } else {
+        throw new Error(
+          "The entry is not accessible without superuser rights. Please provide superuser credentials in the config."
+        );
+      }
+    }
+
+    // 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);
+  }
+
+  // Get the data from the response
+  const response = await entryRequest.json();
+
+  return response;
+}

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

@@ -0,0 +1,29 @@
+import type { LiveDataCollection, LiveDataEntry } from "astro";
+import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+import { fetchCollection } from "./fetch-collection";
+import { parseLiveEntry } from "./parse-live-entry";
+
+export async function liveCollectionLoader<TEntry extends PocketBaseEntry>(
+  options: ExperimentalPocketBaseLiveLoaderOptions,
+  token: string | undefined
+): Promise<LiveDataCollection<TEntry> | { error: Error }> {
+  const entries: Array<LiveDataEntry<TEntry>> = [];
+
+  try {
+    await fetchCollection<TEntry>(
+      options,
+      async (chunk) => {
+        entries.push(...chunk.map((entry) => parseLiveEntry(entry, options)));
+      },
+      token,
+      undefined
+    );
+  } catch (error) {
+    return { error: error as Error };
+  }
+
+  return {
+    entries
+  };
+}

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

@@ -0,0 +1,18 @@
+import type { LiveDataEntry } from "astro";
+import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+import { fetchEntry } from "./fetch-entry";
+import { parseLiveEntry } from "./parse-live-entry";
+
+export async function liveEntryLoader<TEntry extends PocketBaseEntry>(
+  id: string,
+  options: ExperimentalPocketBaseLiveLoaderOptions,
+  token: string | undefined
+): Promise<LiveDataEntry<TEntry> | { error: Error }> {
+  try {
+    const entry = await fetchEntry<TEntry>(id, options, token);
+    return parseLiveEntry(entry, options);
+  } catch (error) {
+    return { error: error as Error };
+  }
+}

package/src/loader/load-entries.ts

@@ -1,5 +1,6 @@
 import type { LoaderContext } from "astro/loaders";
 import type { PocketBaseLoaderOptions } from "../types/pocketbase-loader-options.type";
+import { fetchCollection } from "./fetch-collection";
 import { parseEntry } from "./parse-entry";
 
 /**
@@ -9,8 +10,6 @@ import { parseEntry } from "./parse-entry";
  * @param context Context of the loader.
  * @param superuserToken Superuser token to access all resources.
  * @param lastModified Date of the last fetch to only update changed entries.
- *
- * @returns `true` if the collection has an updated column, `false` otherwise.
  */
 export async function loadEntries(
   options: PocketBaseLoaderOptions,
@@ -18,18 +17,6 @@ export async function loadEntries(
   superuserToken: string | undefined,
   lastModified: string | undefined
 ): Promise<void> {
-  // Build the URL for the collections endpoint
-  const collectionUrl = new URL(
-    `api/collections/${options.collectionName}/records`,
-    options.url
-  ).href;
-
-  // Create the headers for the request to append the superuser token (if available)
-  const collectionHeaders = new Headers();
-  if (superuserToken) {
-    collectionHeaders.set("Authorization", superuserToken);
-  }
-
   // Log the fetching of the entries
   context.logger.info(
     `Fetching${lastModified ? " modified" : ""} data${
@@ -37,80 +24,27 @@ export async function loadEntries(
     }${superuserToken ? " as superuser" : ""}`
   );
 
-  // Prepare pagination variables
-  let page = 0;
-  let totalPages = 0;
-  let entries = 0;
-
-  // Fetch all (modified) entries
-  do {
-    // Build search parameters
-    const searchParams = new URLSearchParams({
-      page: `${++page}`,
-      perPage: "100"
-    });
-
-    const filters = [];
-    if (lastModified && options.updatedField) {
-      // If `lastModified` is set, only fetch entries that have been modified since the last fetch
-      filters.push(`(${options.updatedField}>"${lastModified}")`);
-      // Sort by the updated field and id
-      searchParams.set("sort", `-${options.updatedField},id`);
-    }
-    if (options.filter) {
-      filters.push(`(${options.filter})`);
-    }
-
-    // Add filters to search parameters
-    if (filters.length > 0) {
-      searchParams.set("filter", filters.join("&&"));
-    }
-
-    // Fetch entries from the collection
-    const collectionRequest = await fetch(
-      `${collectionUrl}?${searchParams.toString()}`,
-      {
-        headers: collectionHeaders
+  let numEntries = 0;
+  await fetchCollection(
+    options,
+    async (entries) => {
+      // Parse and store the entries
+      for (const entry of entries) {
+        await parseEntry(entry, context, options);
       }
-    );
-
-    // If the request was not successful, print the error message and return
-    if (!collectionRequest.ok) {
-      // If the collection is locked, an superuser token is required
-      if (collectionRequest.status === 403) {
-        throw new Error(
-          `The collection is not accessible without superuser rights. Please provide superuser credentials in the config.`
-        );
-      }
-
-      // 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);
-    }
 
-    // Get the data from the response
-    const response = await collectionRequest.json();
-
-    // Parse and store the entries
-    for (const entry of response.items) {
-      await parseEntry(entry, context, options);
-    }
-
-    // Update the page and total pages
-    page = response.page;
-    totalPages = response.totalPages;
-    entries += response.items.length;
-  } while (page < totalPages);
+      numEntries += entries.length;
+    },
+    superuserToken,
+    lastModified
+  );
 
   // Log the number of fetched entries
   if (lastModified) {
     context.logger.info(
-      `Updated ${entries}/${context.store.keys().length} entries.`
+      `Updated ${numEntries}/${context.store.keys().length} entries.`
     );
   } else {
-    context.logger.info(`Fetched ${entries} entries.`);
+    context.logger.info(`Fetched ${numEntries} entries.`);
   }
 }

package/src/loader/loader.ts

@@ -1,15 +1,18 @@
 import type { LoaderContext } from "astro/loaders";
 import packageJson from "../../package.json";
 import type { PocketBaseLoaderOptions } from "../types/pocketbase-loader-options.type";
-import { getSuperuserToken } from "../utils/get-superuser-token";
 import { shouldRefresh } from "../utils/should-refresh";
 import { cleanupEntries } from "./cleanup-entries";
 import { handleRealtimeUpdates } from "./handle-realtime-updates";
 import { loadEntries } from "./load-entries";
 
+/**
+ * Load entries from a PocketBase collection.
+ */
 export async function loader(
   context: LoaderContext,
-  options: PocketBaseLoaderOptions
+  options: PocketBaseLoaderOptions,
+  token: string | undefined
 ): Promise<void> {
   context.logger.label = `pocketbase-loader:${options.collectionName}`;
 
@@ -59,16 +62,6 @@ export async function loader(
     lastModified = undefined;
   }
 
-  // Try to get a superuser token to access all resources.
-  let token: string | undefined;
-  if (options.superuserCredentials) {
-    token = await getSuperuserToken(
-      options.url,
-      options.superuserCredentials,
-      context.logger
-    );
-  }
-
   if (context.store.keys().length > 0) {
     // Cleanup entries that are no longer in the collection
     await cleanupEntries(options, context, token);

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

@@ -0,0 +1,49 @@
+import type { LiveDataEntry } from "astro";
+import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
+import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+
+export function parseLiveEntry<TEntry extends PocketBaseEntry>(
+  entry: TEntry,
+  options: ExperimentalPocketBaseLiveLoaderOptions
+): LiveDataEntry<TEntry> {
+  let updated: string | undefined;
+  if (options.updatedField) {
+    // If an updated field is provided, use it to determine the last modified date
+    updated = `${entry[options.updatedField]}`;
+  }
+
+  if (!options.contentFields) {
+    return {
+      id: entry.id,
+      data: entry,
+      cacheHint: {
+        tags: [`${options.collectionName}-${entry.id}`],
+        lastModified: updated ? new Date(updated) : undefined
+      }
+    };
+  }
+
+  let content: string;
+  if (typeof options.contentFields === "string") {
+    // If a single content field is provided, use it directly
+    content = `${entry[options.contentFields]}`;
+  } else {
+    // If multiple content fields are provided, concatenate them with `<section>` tags
+    content = options.contentFields
+      .map((field) => `<section>${entry[field]}</section>`)
+      .join("");
+  }
+
+  return {
+    id: entry.id,
+    data: entry,
+    // @ts-expect-error - Docs say this is possible
+    rendered: {
+      html: content
+    },
+    cacheHint: {
+      tags: [`${options.collectionName}-${entry.id}`],
+      lastModified: updated ? new Date(updated) : undefined
+    }
+  };
+}

package/src/pocketbase-loader.ts

@@ -1,7 +1,16 @@
-import type { Loader } from "astro/loaders";
+import type { LiveDataCollection, LiveDataEntry } from "astro";
+import type { LiveLoader, Loader } from "astro/loaders";
+import type { ZodSchema } from "astro/zod";
+import { liveCollectionLoader } from "./loader/live-collection-loader";
+import { liveEntryLoader } from "./loader/live-entry-loader";
 import { loader } from "./loader/loader";
 import { generateSchema } from "./schema/generate-schema";
-import type { PocketBaseLoaderOptions } from "./types/pocketbase-loader-options.type";
+import type { PocketBaseEntry } from "./types/pocketbase-entry.type";
+import type {
+  ExperimentalPocketBaseLiveLoaderOptions,
+  PocketBaseLoaderOptions
+} from "./types/pocketbase-loader-options.type";
+import { getSuperuserToken } from "./utils/get-superuser-token";
 
 /**
  * Loader for collections stored in PocketBase.
@@ -9,11 +18,97 @@ import type { PocketBaseLoaderOptions } from "./types/pocketbase-loader-options.
  * @param options Options for the loader. See {@link PocketBaseLoaderOptions} for more details.
  */
 export function pocketbaseLoader(options: PocketBaseLoaderOptions): Loader {
+  let tokenPromise: Promise<string | undefined>;
+  if (options.superuserCredentials) {
+    if ("impersonateToken" in options.superuserCredentials) {
+      // Impersonate token provided, so use it directly.
+      tokenPromise = Promise.resolve(
+        options.superuserCredentials.impersonateToken
+      );
+    } else {
+      // Email and password provided, so get a temporary superuser token.
+      tokenPromise = getSuperuserToken(
+        options.url,
+        options.superuserCredentials
+      );
+    }
+  } else {
+    // No credentials provided, so no token can be used.
+    tokenPromise = Promise.resolve(undefined);
+  }
+
   return {
     name: "pocketbase-loader",
-    // Load the entries from the collection
-    load: async (context) => loader(context, options),
-    // Generate the schema for the collection according to the API
-    schema: async () => await generateSchema(options)
+    load: async (context): Promise<void> => {
+      if (options.experimental?.liveTypesOnly) {
+        context.logger.label = `pocketbase-loader:${options.collectionName}`;
+        context.logger.info(
+          "Experimental live types only mode enabled. No data will be loaded, only types will be generated."
+        );
+        return;
+      }
+
+      const token = await tokenPromise;
+
+      // Load the entries from the collection
+      await loader(context, options, token);
+    },
+    schema: async (): Promise<ZodSchema> => {
+      const token = await tokenPromise;
+
+      // Generate the schema for the collection according to the API
+      return await generateSchema(options, token);
+    }
+  };
+}
+
+/**
+ * Live loader for collections stored in PocketBase.
+ * This loader is currently experimental and may change in any future release.
+ *
+ * @param options Options for the live loader. See {@link ExperimentalPocketBaseLiveLoaderOptions} for more details.
+ */
+export function experimentalPocketbaseLiveLoader<
+  TEntry extends PocketBaseEntry
+>(
+  options: ExperimentalPocketBaseLiveLoaderOptions
+): LiveLoader<TEntry, { id: string }> {
+  let tokenPromise: Promise<string | undefined>;
+  if (options.superuserCredentials) {
+    if ("impersonateToken" in options.superuserCredentials) {
+      // Impersonate token provided, so use it directly.
+      tokenPromise = Promise.resolve(
+        options.superuserCredentials.impersonateToken
+      );
+    } else {
+      // Email and password provided, so get a temporary superuser token.
+      tokenPromise = getSuperuserToken(
+        options.url,
+        options.superuserCredentials
+      );
+    }
+  } else {
+    // No credentials provided, so no token can be used.
+    tokenPromise = Promise.resolve(undefined);
+  }
+
+  return {
+    name: "pocketbase-live-loader",
+    loadCollection: async (): Promise<
+      LiveDataCollection<TEntry> | { error: Error }
+    > => {
+      const token = await tokenPromise;
+
+      // Load entries from the collection
+      return await liveCollectionLoader(options, token);
+    },
+    loadEntry: async ({
+      filter
+    }): Promise<LiveDataEntry<TEntry> | { error: Error }> => {
+      const token = await tokenPromise;
+
+      // Load a single entry from the collection
+      return await liveEntryLoader(filter.id, options, token);
+    }
   };
 }

package/src/schema/generate-schema.ts

@@ -28,14 +28,18 @@ const VALID_ID_TYPES = ["text", "number", "email", "url", "date"];
  * If a path to a local schema file is provided, the schema is read from the file.
  *
  * @param options Options for the loader. See {@link PocketBaseLoaderOptions} for more details.
+ * @param token The superuser token to authenticate the request.
  */
 export async function generateSchema(
-  options: PocketBaseLoaderOptions
+  options: PocketBaseLoaderOptions,
+  token: string | undefined
 ): Promise<ZodSchema> {
   let collection: PocketBaseCollection | undefined;
 
-  // Try to get the schema directly from the PocketBase instance
-  collection = await getRemoteSchema(options);
+  if (token) {
+    // Try to get the schema directly from the PocketBase instance
+    collection = await getRemoteSchema(options, token);
+  }
 
   const hasSuperuserRights = !!collection || !!options.superuserCredentials;
 
@@ -61,7 +65,8 @@ export async function generateSchema(
     collection,
     options.jsonSchemas,
     hasSuperuserRights,
-    options.improveTypes ?? false
+    options.improveTypes ?? false,
+    options.experimental?.liveTypesOnly ?? false
   );
 
   // Check if custom id field is present

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

@@ -1,30 +1,16 @@
 import type { PocketBaseLoaderOptions } from "../types/pocketbase-loader-options.type";
 import type { PocketBaseCollection } from "../types/pocketbase-schema.type";
-import { getSuperuserToken } from "../utils/get-superuser-token";
 
 /**
  * Fetches the schema for the specified collection from the PocketBase instance.
  *
  * @param options Options for the loader. See {@link PocketBaseLoaderOptions} for more details.
+ * @param token The superuser token to authenticate the request.
  */
 export async function getRemoteSchema(
-  options: PocketBaseLoaderOptions
+  options: PocketBaseLoaderOptions,
+  token: string
 ): Promise<PocketBaseCollection | undefined> {
-  if (!options.superuserCredentials) {
-    return undefined;
-  }
-
-  // Get a superuser token
-  const token = await getSuperuserToken(
-    options.url,
-    options.superuserCredentials
-  );
-
-  // If the token is invalid try another method
-  if (!token) {
-    return undefined;
-  }
-
   // Build URL and headers for the schema request
   const schemaUrl = new URL(
     `api/collections/${options.collectionName}`,

package/src/schema/parse-schema.ts

@@ -8,7 +8,8 @@ export function parseSchema(
   collection: PocketBaseCollection,
   customSchemas: Record<string, z.ZodType> | undefined,
   hasSuperuserRights: boolean,
-  improveTypes: boolean
+  improveTypes: boolean,
+  experimentalLiveTypesOnly?: boolean
 ): Record<string, z.ZodType> {
   // Prepare the schemas fields
   const fields: Record<string, z.ZodType> = {};
@@ -32,6 +33,11 @@ export function parseSchema(
         break;
       case "date":
       case "autodate":
+        if (experimentalLiveTypesOnly) {
+          // If experimental live types only mode is enabled, treat dates as strings
+          fieldType = z.string();
+          break;
+        }
         // Coerce and parse the value as a date
         fieldType = z.coerce.date();
         break;

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

@@ -58,16 +58,24 @@ export interface PocketBaseLoaderOptions {
    * Credentials of a superuser to get full access to the PocketBase instance.
    * This is required to get automatic type generation without a local schema, to access all resources even if they are not public and to fetch content of hidden fields.
    */
-  superuserCredentials?: {
-    /**
-     * Email of the superuser.
-     */
-    email: string;
-    /**
-     * Password of the superuser.
-     */
-    password: string;
-  };
+  superuserCredentials?:
+    | {
+        /**
+         * Email of the superuser.
+         */
+        email: string;
+        /**
+         * Password of the superuser.
+         */
+        password: string;
+      }
+    | {
+        /**
+         * Impersonate auth token of the superuser.
+         * This token will take precedence over the email and password.
+         */
+        impersonateToken: string;
+      };
   /**
    * File path to the local schema file.
    * This file will be used to generate the schema for the collection.
@@ -90,4 +98,27 @@ export interface PocketBaseLoaderOptions {
    * The PocketBase API does always return at least `0` or `false` as the default values, even though the fields are not marked as required in the schema.
    */
   improveTypes?: boolean;
+  /**
+   * Experimental options for the loader.
+   */
+  experimental?: {
+    /**
+     * Whether to only create types for the live loader.
+     * This will not load any data, but only generate types that can be used with the live loader.
+     */
+    liveTypesOnly?: boolean;
+  };
 }
+
+/**
+ * Options for the PocketBase live loader.
+ */
+export type ExperimentalPocketBaseLiveLoaderOptions = Pick<
+  PocketBaseLoaderOptions,
+  | "url"
+  | "collectionName"
+  | "contentFields"
+  | "updatedField"
+  | "filter"
+  | "superuserCredentials"
+>;