astro-loader-pocketbase 2.4.2-next.1 → 2.5.0-next.2

package/README.md

@@ -108,22 +108,24 @@ The loader will also automatically convert the value into a slug to be easily us
 It's recommended to use e.g. the title of the entry to be easily searchable and readable.
 **Do not use e.g. rich text fields as ids.**
 
-### Improved types
+### Filtering entries
 
-By default PocketBase reports `number` and `boolean` fields as not required, even though the API will always return `0` and `false` respectively if no value is set.
-This means that the loader will add `undefined` to the type of these fields.
-If you want to enforce that these fields are always present, you can set the `improveTypes` option to `true`.
+By default the loader will fetch all entries in the specified collection.
+If you want to restrict the entries to a specific subset, you can use the `filter` option.
 
 ```ts
 const blog = defineCollection({
   loader: pocketbaseLoader({
     ...options,
-    improveTypes: true
+    filter: "<filter>"
   })
 });
 ```
 
-This will remove `undefined` from the type of these fields and mark them as required.
+For example, if you want to only fetch entries that are released but not deleted, you can use `"release >= @now && deleted = false"`.
+This filter will be added to the PocketBase API request and will only fetch entries that match the filter.
+This is in addition to the built-in filtering of the loader, which handles the incremental builds using the `updated` field.
+For more information on how to use filters, check out the [PocketBase documentation](https://pocketbase.io/docs/api-records/#listsearch-records).
 
 ## Type generation
 
@@ -172,6 +174,23 @@ When superuser credentials are provided, the loader will **always use the remote
 If you don't want to use the automatic type generation, you can also [provide your own schema manually](https://docs.astro.build/en/guides/content-collections/#defining-the-collection-schema).
 This manual schema will **always override the automatic type generation**.
 
+### Improved types
+
+By default PocketBase reports `number` and `boolean` fields as not required, even though the API will always return `0` and `false` respectively if no value is set.
+This means that the loader will add `undefined` to the type of these fields.
+If you want to enforce that these fields are always present, you can set the `improveTypes` option to `true`.
+
+```ts
+const blog = defineCollection({
+  loader: pocketbaseLoader({
+    ...options,
+    improveTypes: true
+  })
+});
+```
+
+This will remove `undefined` from the type of these fields and mark them as required.
+
 ## All options
 
 | Option                 | Type                                  | Required | Description                                                                                                     |
@@ -181,6 +200,7 @@ This manual schema will **always override the automatic type generation**.
 | `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.                                            |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-loader-pocketbase",
-  "version": "2.4.2-next.1",
+  "version": "2.5.0-next.2",
   "description": "A content loader for Astro that uses the PocketBase API",
   "keywords": [
     "astro",

package/src/loader/handle-realtime-updates.ts

@@ -12,6 +12,14 @@ export async function handleRealtimeUpdates(
   context: LoaderContext,
   options: PocketBaseLoaderOptions
 ): Promise<boolean> {
+  // Check if a custom filter is set
+  if (options.filter) {
+    // Updating an entry directly via realtime updates is not supported when using a custom filter.
+    // This is because the filter can only be applied via the get request and is not considered in the realtime updates.
+    // Updating the entry directly would bypass the filter and could lead to inconsistent data.
+    return false;
+  }
+
   // Check if data was provided via the refresh context
   if (!context.refreshContextData?.data) {
     return false;

package/src/loader/load-entries.ts

@@ -44,14 +44,31 @@ export async function loadEntries(
 
   // 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
-    // If `lastModified` is set, only fetch entries that have been modified since the last fetch
     const collectionRequest = await fetch(
-      `${collectionUrl}?page=${++page}&perPage=100${
-        lastModified && options.updatedField
-          ? `&sort=-${options.updatedField},id&filter=(${options.updatedField}>"${lastModified}")`
-          : ""
-      }`,
+      `${collectionUrl}?${searchParams.toString()}`,
       {
         headers: collectionHeaders
       }

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

@@ -37,6 +37,23 @@ export interface PocketBaseLoaderOptions {
    * This field is used to only fetch entries that have been modified since the last build.
    */
   updatedField?: string;
+  /**
+   * Custom filter that is applied when loading data from PocketBase.
+   * Valid syntax can be found in the [PocketBase documentation](https://pocketbase.io/docs/api-records/#listsearch-records)
+   *
+   * The loader will also add it's own filters for incremental builds.
+   * These will be added to your custom filter query.
+   *
+   * Example:
+   * ```ts
+   * // config:
+   * filter: 'release >= @now && deleted = false'
+   *
+   * // request
+   * `?filter=(${loaderFilter})&&(release >= @now && deleted = false)`
+   * ```
+   */
+  filter?: string;
   /**
    * 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.