@matvdt/js-toolkit 0.0.1-canary.2 → 0.0.1-canary.20

package/dist/payload-cms/server/index.cjs

@@ -0,0 +1,247 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/payload-cms/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  cacheKey: () => cacheKey,
+  configurePayload: () => configurePayload,
+  createCollection: () => createCollection,
+  createGlobal: () => createGlobal,
+  getPayload: () => getPayload,
+  payload: () => payload,
+  revalidateCollection: () => revalidateCollection,
+  revalidateDoc: () => revalidateDoc,
+  revalidateGlobal: () => revalidateGlobal,
+  withCache: () => withCache
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/payload-cms/server/cache.ts
+var import_cache = require("next/cache");
+function cacheKey(collection, method, args) {
+  return [`payload:${collection}:${method}`, JSON.stringify(args)];
+}
+function withCache(collection, method, args, tags, fn) {
+  return (0, import_cache.unstable_cache)(fn, cacheKey(collection, method, args), { tags })();
+}
+function revalidateCollection(collection) {
+  (0, import_cache.revalidateTag)(`collection:${collection}`, "max");
+}
+function revalidateDoc(collection, id) {
+  (0, import_cache.revalidateTag)(`doc:${collection}:${id}`, "max");
+}
+function revalidateGlobal(slug) {
+  (0, import_cache.revalidateTag)(`global:${slug}`, "max");
+}
+
+// src/payload-cms/server/payload.ts
+var import_react = require("react");
+
+// src/payload-cms/server/get-payload.ts
+var import_payload = require("payload");
+var payloadConfig;
+function configurePayload(config) {
+  if (payloadConfig) return;
+  payloadConfig = config;
+}
+var getPayload = async (config) => {
+  const resolvedConfig = config ?? payloadConfig;
+  if (!resolvedConfig) {
+    throw new Error(
+      "[@matvdt/js-toolkit] No Payload config available. Call configurePayload(config) once at app startup, or pass config explicitly to getPayload(config)."
+    );
+  }
+  return (0, import_payload.getPayload)({ config: resolvedConfig });
+};
+
+// src/payload-cms/server/payload.ts
+var getClient = (0, import_react.cache)(async () => {
+  return await getPayload();
+});
+var payload = {
+  findOne: async (collection, options) => {
+    return withCache(collection, "findOne", [options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      const res = await client.find({
+        ...options,
+        collection,
+        limit: 1
+      });
+      return res.docs[0] ?? null;
+    });
+  },
+  findBySlug: async (collection, slug, options) => {
+    return payload.findOne(
+      collection,
+      {
+        ...options,
+        where: {
+          ...options?.where,
+          slug: { equals: slug }
+        }
+      }
+    );
+  },
+  find: async (collection, options) => {
+    return withCache(collection, "find", [options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      return client.find({
+        ...options,
+        collection
+      });
+    });
+  },
+  findAll: async (collection, options) => {
+    return withCache(collection, "findAll", [options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      const res = await client.find({
+        ...options,
+        collection,
+        limit: options?.limit ?? 100
+      });
+      return res.docs;
+    });
+  },
+  findByID: async (collection, id, options) => {
+    return withCache(collection, "findByID", [id, options], [`collection:${collection}`, `doc:${collection}:${id}`], async () => {
+      const client = await getClient();
+      return client.findByID({
+        ...options,
+        collection,
+        id
+      });
+    });
+  },
+  create: async (collection, data, options) => {
+    const client = await getClient();
+    const result = await client.create({
+      ...options,
+      collection,
+      data
+    });
+    revalidateCollection(collection);
+    return result;
+  },
+  update: async (collection, id, data, options) => {
+    const client = await getClient();
+    const result = await client.update({
+      ...options,
+      collection,
+      id,
+      data
+    });
+    revalidateCollection(collection);
+    revalidateDoc(collection, id);
+    return result;
+  },
+  updateMany: async (collection, where, data, options) => {
+    const client = await getClient();
+    const result = await client.update({
+      ...options,
+      collection,
+      where,
+      data,
+      id: void 0
+    });
+    revalidateCollection(collection);
+    return result;
+  },
+  delete: async (collection, id, options) => {
+    const client = await getClient();
+    const result = await client.delete({
+      ...options,
+      collection,
+      id,
+      where: void 0
+    });
+    revalidateCollection(collection);
+    revalidateDoc(collection, id);
+    return result;
+  },
+  deleteMany: async (collection, where, options) => {
+    const client = await getClient();
+    const result = await client.delete({
+      ...options,
+      collection,
+      where,
+      id: void 0
+    });
+    revalidateCollection(collection);
+    return result;
+  },
+  global: async (slug) => {
+    return withCache("global", slug, [], [`global:${slug}`], async () => {
+      const client = await getClient();
+      return client.findGlobal({ slug });
+    });
+  },
+  aggregate: async (collection, pipeline, options) => {
+    return withCache(collection, "aggregate", [pipeline, options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      return client.db.collections[collection].aggregate(pipeline, options);
+    });
+  },
+  raw: getClient
+};
+
+// src/payload-cms/server/create-collection.ts
+function createCollection(collection, extend) {
+  const base = {
+    find: (options) => payload.find(collection, options),
+    findOne: (options) => payload.findOne(collection, options),
+    findByID: (id, options) => payload.findByID(collection, id, options),
+    findBySlug: (slug, options) => payload.findBySlug(collection, slug, options),
+    findAll: (options) => payload.findAll(collection, options),
+    update: (id, data, options) => payload.update(collection, id, data, options),
+    updateMany: (where, data, options) => payload.updateMany(collection, where, data, options),
+    delete: (id, options) => payload.delete(collection, id, options),
+    deleteMany: (where, options) => payload.deleteMany(collection, where, options)
+  };
+  const extended = extend ? extend(base) : void 0;
+  return {
+    ...base,
+    ...extended
+  };
+}
+
+// src/payload-cms/server/create-global.ts
+function createGlobal(slug, extend) {
+  const base = {
+    get: () => payload.global(slug)
+  };
+  const extended = extend ? extend(base) : void 0;
+  return {
+    ...base,
+    ...extended
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheKey,
+  configurePayload,
+  createCollection,
+  createGlobal,
+  getPayload,
+  payload,
+  revalidateCollection,
+  revalidateDoc,
+  revalidateGlobal,
+  withCache
+});

package/dist/payload-cms/server/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cache';
+export * from './create-collection';
+export * from './create-global';
+export * from './get-payload';
+export * from './payload';

package/dist/payload-cms/server/index.js

@@ -0,0 +1,211 @@
+// src/payload-cms/server/cache.ts
+import { unstable_cache, revalidateTag } from "next/cache";
+function cacheKey(collection, method, args) {
+  return [`payload:${collection}:${method}`, JSON.stringify(args)];
+}
+function withCache(collection, method, args, tags, fn) {
+  return unstable_cache(fn, cacheKey(collection, method, args), { tags })();
+}
+function revalidateCollection(collection) {
+  revalidateTag(`collection:${collection}`, "max");
+}
+function revalidateDoc(collection, id) {
+  revalidateTag(`doc:${collection}:${id}`, "max");
+}
+function revalidateGlobal(slug) {
+  revalidateTag(`global:${slug}`, "max");
+}
+
+// src/payload-cms/server/payload.ts
+import { cache } from "react";
+
+// src/payload-cms/server/get-payload.ts
+import { getPayload as getPayloadSDK } from "payload";
+var payloadConfig;
+function configurePayload(config) {
+  if (payloadConfig) return;
+  payloadConfig = config;
+}
+var getPayload = async (config) => {
+  const resolvedConfig = config ?? payloadConfig;
+  if (!resolvedConfig) {
+    throw new Error(
+      "[@matvdt/js-toolkit] No Payload config available. Call configurePayload(config) once at app startup, or pass config explicitly to getPayload(config)."
+    );
+  }
+  return getPayloadSDK({ config: resolvedConfig });
+};
+
+// src/payload-cms/server/payload.ts
+var getClient = cache(async () => {
+  return await getPayload();
+});
+var payload = {
+  findOne: async (collection, options) => {
+    return withCache(collection, "findOne", [options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      const res = await client.find({
+        ...options,
+        collection,
+        limit: 1
+      });
+      return res.docs[0] ?? null;
+    });
+  },
+  findBySlug: async (collection, slug, options) => {
+    return payload.findOne(
+      collection,
+      {
+        ...options,
+        where: {
+          ...options?.where,
+          slug: { equals: slug }
+        }
+      }
+    );
+  },
+  find: async (collection, options) => {
+    return withCache(collection, "find", [options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      return client.find({
+        ...options,
+        collection
+      });
+    });
+  },
+  findAll: async (collection, options) => {
+    return withCache(collection, "findAll", [options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      const res = await client.find({
+        ...options,
+        collection,
+        limit: options?.limit ?? 100
+      });
+      return res.docs;
+    });
+  },
+  findByID: async (collection, id, options) => {
+    return withCache(collection, "findByID", [id, options], [`collection:${collection}`, `doc:${collection}:${id}`], async () => {
+      const client = await getClient();
+      return client.findByID({
+        ...options,
+        collection,
+        id
+      });
+    });
+  },
+  create: async (collection, data, options) => {
+    const client = await getClient();
+    const result = await client.create({
+      ...options,
+      collection,
+      data
+    });
+    revalidateCollection(collection);
+    return result;
+  },
+  update: async (collection, id, data, options) => {
+    const client = await getClient();
+    const result = await client.update({
+      ...options,
+      collection,
+      id,
+      data
+    });
+    revalidateCollection(collection);
+    revalidateDoc(collection, id);
+    return result;
+  },
+  updateMany: async (collection, where, data, options) => {
+    const client = await getClient();
+    const result = await client.update({
+      ...options,
+      collection,
+      where,
+      data,
+      id: void 0
+    });
+    revalidateCollection(collection);
+    return result;
+  },
+  delete: async (collection, id, options) => {
+    const client = await getClient();
+    const result = await client.delete({
+      ...options,
+      collection,
+      id,
+      where: void 0
+    });
+    revalidateCollection(collection);
+    revalidateDoc(collection, id);
+    return result;
+  },
+  deleteMany: async (collection, where, options) => {
+    const client = await getClient();
+    const result = await client.delete({
+      ...options,
+      collection,
+      where,
+      id: void 0
+    });
+    revalidateCollection(collection);
+    return result;
+  },
+  global: async (slug) => {
+    return withCache("global", slug, [], [`global:${slug}`], async () => {
+      const client = await getClient();
+      return client.findGlobal({ slug });
+    });
+  },
+  aggregate: async (collection, pipeline, options) => {
+    return withCache(collection, "aggregate", [pipeline, options], [`collection:${collection}`], async () => {
+      const client = await getClient();
+      return client.db.collections[collection].aggregate(pipeline, options);
+    });
+  },
+  raw: getClient
+};
+
+// src/payload-cms/server/create-collection.ts
+function createCollection(collection, extend) {
+  const base = {
+    find: (options) => payload.find(collection, options),
+    findOne: (options) => payload.findOne(collection, options),
+    findByID: (id, options) => payload.findByID(collection, id, options),
+    findBySlug: (slug, options) => payload.findBySlug(collection, slug, options),
+    findAll: (options) => payload.findAll(collection, options),
+    update: (id, data, options) => payload.update(collection, id, data, options),
+    updateMany: (where, data, options) => payload.updateMany(collection, where, data, options),
+    delete: (id, options) => payload.delete(collection, id, options),
+    deleteMany: (where, options) => payload.deleteMany(collection, where, options)
+  };
+  const extended = extend ? extend(base) : void 0;
+  return {
+    ...base,
+    ...extended
+  };
+}
+
+// src/payload-cms/server/create-global.ts
+function createGlobal(slug, extend) {
+  const base = {
+    get: () => payload.global(slug)
+  };
+  const extended = extend ? extend(base) : void 0;
+  return {
+    ...base,
+    ...extended
+  };
+}
+export {
+  cacheKey,
+  configurePayload,
+  createCollection,
+  createGlobal,
+  getPayload,
+  payload,
+  revalidateCollection,
+  revalidateDoc,
+  revalidateGlobal,
+  withCache
+};

package/dist/payload-cms/{utils/db.d.ts → server/payload.d.ts}

@@ -1,19 +1,23 @@
-import type { CollectionSlug, GlobalSlug, Where } from 'payload';
-import { getPayload } from '../client/get-payload';
-export type FindAllOptions = Omit<Parameters<Awaited<ReturnType<typeof getPayload>>['find']>[0], 'collection'>;
+import type { CollectionSlug, DataFromCollectionSlug, DataFromGlobalSlug, GlobalSlug, PaginatedDocs, Where } from 'payload';
+import { getPayload } from './get-payload';
+import { PipelineStage, Aggregate, AggregateOptions } from "mongoose";
+export type FindOptions = Omit<Parameters<Awaited<ReturnType<typeof getPayload>>['find']>[0], 'collection'>;
+export type FindByIDOptions = Omit<Parameters<Awaited<ReturnType<typeof getPayload>>['findByID']>[0], 'collection' | 'id'>;
 export type UpdateOptions = Omit<Parameters<Awaited<ReturnType<typeof getPayload>>['update']>[0], 'collection' | 'id' | 'data' | 'where'>;
 export type DeleteOptions = Omit<Parameters<Awaited<ReturnType<typeof getPayload>>['delete']>[0], 'collection' | 'id' | 'where'>;
 export type UpdateData = Parameters<Awaited<ReturnType<typeof getPayload>>['update']>[0]['data'];
-export declare const db: {
-    findOne: <TSlug extends CollectionSlug>(collection: TSlug, where?: Where) => Promise<import("payload").JsonObject & import("payload").TypeWithID>;
-    findBySlug: <TSlug extends CollectionSlug>(collection: TSlug, slug: string) => Promise<import("payload").JsonObject & import("payload").TypeWithID>;
-    findAll: <TSlug extends CollectionSlug>(collection: TSlug, options?: FindAllOptions) => Promise<(import("payload").JsonObject & import("payload").TypeWithID)[]>;
-    findByID: <TSlug extends CollectionSlug>(collection: TSlug, id: string | number) => Promise<import("payload").JsonObject & import("payload").TypeWithID>;
+export declare const payload: {
+    findOne: <TSlug extends CollectionSlug>(collection: TSlug, options?: FindOptions) => Promise<DataFromCollectionSlug<TSlug>>;
+    findBySlug: <TSlug extends CollectionSlug>(collection: TSlug, slug: string, options?: FindOptions) => Promise<DataFromCollectionSlug<TSlug>>;
+    find: <TSlug extends CollectionSlug>(collection: TSlug, options?: FindOptions) => Promise<PaginatedDocs<DataFromCollectionSlug<TSlug>>>;
+    findAll: <TSlug extends CollectionSlug>(collection: TSlug, options?: FindOptions) => Promise<DataFromCollectionSlug<TSlug>[]>;
+    findByID: <TSlug extends CollectionSlug>(collection: TSlug, id: string | number, options?: FindByIDOptions) => Promise<DataFromCollectionSlug<TSlug>>;
     create: <TSlug extends CollectionSlug>(collection: TSlug, data: Parameters<Awaited<ReturnType<typeof getPayload>>['create']>[0]['data'], options?: Omit<Parameters<Awaited<ReturnType<typeof getPayload>>['create']>[0], 'collection' | 'data'>) => Promise<import("payload").JsonObject & import("payload").TypeWithID>;
     update: <TSlug extends CollectionSlug>(collection: TSlug, id: string | number, data: UpdateData, options?: UpdateOptions) => Promise<import("payload").JsonObject & import("payload").TypeWithID>;
     updateMany: <TSlug extends CollectionSlug>(collection: TSlug, where: Where, data: UpdateData, options?: UpdateOptions) => Promise<import("payload").BulkOperationResult<TSlug, import("payload").SelectExcludeType | import("payload").SelectIncludeType>>;
     delete: <TSlug extends CollectionSlug>(collection: TSlug, id: string | number, options?: DeleteOptions) => Promise<import("payload").JsonObject & import("payload").TypeWithID>;
     deleteMany: <TSlug extends CollectionSlug>(collection: TSlug, where: Where, options?: DeleteOptions) => Promise<import("payload").BulkOperationResult<TSlug, import("payload").SelectExcludeType | import("payload").SelectIncludeType>>;
-    global: <TSlug extends GlobalSlug>(slug: TSlug) => Promise<import("payload").JsonObject>;
+    global: <TSlug extends GlobalSlug>(slug: TSlug) => Promise<DataFromGlobalSlug<TSlug>>;
+    aggregate: <TSlug extends CollectionSlug, TData = any>(collection: TSlug, pipeline?: PipelineStage[], options?: AggregateOptions) => Promise<Aggregate<TData[]>>;
     raw: () => Promise<import("payload").BasePayload>;
 };

package/dist/payload-cms/utils/has-id.d.ts

@@ -0,0 +1,5 @@
+export declare function hasId<T>(item: T & {
+    id?: string | null;
+}): item is T & {
+    id: string;
+};

package/dist/payload-cms/utils/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/payload-cms/utils/index.ts
@@ -33,11 +23,10 @@ __export(utils_exports, {
   MONGO_ID_REGEX: () => MONGO_ID_REGEX,
   asPopulated: () => asPopulated,
   assertPopulated: () => assertPopulated,
-  createCollection: () => createCollection,
-  createGlobal: () => createGlobal,
-  db: () => db,
+  hasId: () => hasId,
   isObjectId: () => isObjectId,
-  isPopulated: () => isPopulated
+  isPopulated: () => isPopulated,
+  unwrapPopulated: () => unwrapPopulated
 });
 module.exports = __toCommonJS(utils_exports);
 
@@ -67,131 +56,28 @@ function assertPopulated(field, fieldName = "Field") {
   }
 }
 
-// src/payload-cms/utils/db.ts
-var import_react = require("react");
-
-// src/payload-cms/client/get-payload.ts
-var import_payload = require("payload");
-var getPayload = async (config) => {
-  if (config) {
-    return (0, import_payload.getPayload)({ config });
-  }
-  const defaultConfig = await import("@payload-config");
-  return (0, import_payload.getPayload)({ config: defaultConfig });
-};
-
-// src/payload-cms/utils/db.ts
-var getClient = (0, import_react.cache)(async () => {
-  return await getPayload();
-});
-var db = {
-  findOne: async (collection, where) => {
-    const payload = await getClient();
-    const res = await payload.find({ collection, where, limit: 1 });
-    return res.docs[0] ?? null;
-  },
-  findBySlug: async (collection, slug) => {
-    return db.findOne(collection, { slug: { equals: slug } });
-  },
-  findAll: async (collection, options) => {
-    const payload = await getClient();
-    const res = await payload.find({
-      collection,
-      limit: options?.limit ?? 100,
-      ...options
-    });
-    return res.docs;
-  },
-  findByID: async (collection, id) => {
-    const payload = await getClient();
-    return payload.findByID({ collection, id });
-  },
-  create: async (collection, data, options) => {
-    const payload = await getClient();
-    return payload.create({ collection, data, ...options });
-  },
-  update: async (collection, id, data, options) => {
-    const payload = await getClient();
-    return payload.update({
-      collection,
-      id,
-      data,
-      ...options
-    });
-  },
-  updateMany: async (collection, where, data, options) => {
-    const payload = await getClient();
-    return payload.update({
-      collection,
-      where,
-      data,
-      ...options,
-      id: void 0
-    });
-  },
-  delete: async (collection, id, options) => {
-    const payload = await getClient();
-    return payload.delete({
-      collection,
-      id,
-      where: void 0,
-      ...options
-    });
-  },
-  deleteMany: async (collection, where, options) => {
-    const payload = await getClient();
-    return payload.delete({
-      collection,
-      where,
-      id: void 0,
-      ...options
-    });
-  },
-  global: async (slug) => {
-    const payload = await getClient();
-    return payload.findGlobal({ slug });
-  },
-  raw: getClient
-};
-
-// src/payload-cms/utils/create-collection.ts
-function createCollection(collection, extend) {
-  const base = {
-    findOne: (where) => db.findOne(collection, where),
-    findByID: (id) => db.findByID(collection, id),
-    findBySlug: (slug) => db.findBySlug(collection, slug),
-    findAll: (options) => db.findAll(collection, options),
-    update: (id, data, options) => db.update(collection, id, data, options),
-    updateMany: (where, data, options) => db.updateMany(collection, where, data, options),
-    delete: (id, options) => db.delete(collection, id, options),
-    deleteMany: (where, options) => db.deleteMany(collection, where, options)
-  };
-  const extended = extend ? extend(base) : void 0;
-  return {
-    ...base,
-    ...extended
-  };
+// src/payload-cms/utils/has-id.ts
+function hasId(item) {
+  return item.id !== null && item.id !== void 0;
 }
 
-// src/payload-cms/utils/create-global.ts
-function createGlobal(slug, extend) {
-  const base = {
-    get: () => db.global(slug)
-  };
-  const extended = extend ? extend(base) : void 0;
-  return {
-    ...base,
-    ...extended
-  };
+// src/payload-cms/utils/unwrap-populated.ts
+function unwrapPopulated(value, message = "Value is missing or not populated") {
+  if (value === null || value === void 0) {
+    throw new Error(message);
+  }
+  if (typeof value === "string" && isObjectId(value)) {
+    throw new Error(message);
+  }
+  return value;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MONGO_ID_REGEX,
   asPopulated,
   assertPopulated,
-  createCollection,
-  createGlobal,
-  db,
+  hasId,
   isObjectId,
-  isPopulated
+  isPopulated,
+  unwrapPopulated
 });