@btst/plugin-cms 0.0.0-stage → 1.0.0-beta.0

package/LICENSE.md

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

package/dist/api/getters.cjs

@@ -0,0 +1,328 @@
+'use strict';
+
+const schemas = require('../schemas.cjs');
+
+class CMSContentSelectionError extends Error {
+}
+function validateContentReadOptions(contentType, options) {
+  schemas.contentReadOptionsSchema.parse(options ?? {});
+  if (options?.fields === void 0) return;
+  if (options.view !== "content") {
+    throw new CMSContentSelectionError("fields requires view: content");
+  }
+  const properties = contentType ? JSON.parse(contentType.jsonSchema).properties : void 0;
+  for (const field of options.fields) {
+    if (!properties || !Object.hasOwn(properties, field)) {
+      throw new CMSContentSelectionError(
+        `Unknown top-level content field: ${field}`
+      );
+    }
+  }
+}
+function applyContentReadOptions(item, options) {
+  const result = options?.view === "content" ? {
+    id: item.id,
+    slug: item.slug,
+    parsedData: options.fields ? Object.fromEntries(
+      schemas.normalizeContentFields(options.fields).filter((field) => Object.hasOwn(item.parsedData, field)).map((field) => [
+        field,
+        item.parsedData[field]
+      ])
+    ) : item.parsedData,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt
+  } : item;
+  return result;
+}
+function serializeContentType(ct) {
+  const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
+  const migratedJsonSchema = needsMigration ? migrateToUnifiedSchema(ct.jsonSchema, ct.fieldConfig) : ct.jsonSchema;
+  return {
+    id: ct.id,
+    name: ct.name,
+    slug: ct.slug,
+    description: ct.description,
+    jsonSchema: migratedJsonSchema,
+    createdAt: ct.createdAt.toISOString(),
+    updatedAt: ct.updatedAt.toISOString()
+  };
+}
+function migrateToUnifiedSchema(jsonSchemaStr, fieldConfigStr) {
+  if (!fieldConfigStr) return jsonSchemaStr;
+  try {
+    const jsonSchema = JSON.parse(jsonSchemaStr);
+    const fieldConfig = JSON.parse(fieldConfigStr);
+    if (!jsonSchema.properties || typeof fieldConfig !== "object") {
+      return jsonSchemaStr;
+    }
+    for (const [key, config] of Object.entries(fieldConfig)) {
+      if (jsonSchema.properties[key] && typeof config === "object" && config !== null && "fieldType" in config) {
+        jsonSchema.properties[key].fieldType = config.fieldType;
+      }
+    }
+    return JSON.stringify(jsonSchema);
+  } catch {
+    return jsonSchemaStr;
+  }
+}
+function serializeContentItem(item) {
+  return {
+    ...item,
+    createdAt: item.createdAt.toISOString(),
+    updatedAt: item.updatedAt.toISOString()
+  };
+}
+function serializeContentItemWithType(item) {
+  const parsedData = JSON.parse(item.data);
+  return {
+    ...serializeContentItem(item),
+    parsedData,
+    contentType: item.contentType ? serializeContentType(item.contentType) : void 0
+  };
+}
+async function getAllContentTypes(adapter) {
+  const contentTypes = await adapter.findMany({
+    model: "contentType",
+    sortBy: { field: "name", direction: "asc" }
+  });
+  return contentTypes.map(serializeContentType);
+}
+function contentItemMatchesSearch(item, searchLower) {
+  if (item.slug.toLowerCase().includes(searchLower)) return true;
+  const matchesValue = (value) => typeof value === "string" && value.toLowerCase().includes(searchLower);
+  return Object.values(item.parsedData).some((value) => {
+    if (matchesValue(value)) return true;
+    if (Array.isArray(value)) return value.some(matchesValue);
+    if (typeof value === "object" && value !== null) {
+      return Object.values(value).some(matchesValue);
+    }
+    return false;
+  });
+}
+async function getAllContentItems(adapter, contentTypeSlug, params) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return {
+      items: [],
+      total: 0,
+      limit: params?.limit,
+      offset: params?.offset
+    };
+  }
+  validateContentReadOptions(contentType, params);
+  const whereConditions = [
+    {
+      field: "contentTypeId",
+      value: contentType.id,
+      operator: "eq"
+    }
+  ];
+  if (params?.slug) {
+    whereConditions.push({
+      field: "slug",
+      value: params.slug,
+      operator: "eq"
+    });
+  }
+  const search = params?.search?.trim();
+  const needsInMemoryFilter = !!search;
+  const dbTotal = !needsInMemoryFilter ? await adapter.count({
+    model: "contentItem",
+    where: whereConditions
+  }) : void 0;
+  const items = await adapter.findMany({
+    model: "contentItem",
+    where: whereConditions,
+    limit: !needsInMemoryFilter ? params?.limit : schemas.DEFAULT_MAX_PAGE_SIZE,
+    offset: !needsInMemoryFilter ? params?.offset : void 0,
+    sortBy: { field: "createdAt", direction: "desc" },
+    join: { contentType: true }
+  });
+  let result = items.map(serializeContentItemWithType);
+  if (needsInMemoryFilter) {
+    const searchLower = search.toLowerCase();
+    result = result.filter(
+      (item) => contentItemMatchesSearch(item, searchLower)
+    );
+    const total = result.length;
+    const offset = params?.offset ?? 0;
+    const limit = params?.limit;
+    result = result.slice(
+      offset,
+      limit !== void 0 ? offset + limit : void 0
+    );
+    return {
+      items: result.map((item) => applyContentReadOptions(item, params)),
+      total,
+      limit: params?.limit,
+      offset: params?.offset
+    };
+  }
+  return {
+    items: result.map((item) => applyContentReadOptions(item, params)),
+    total: dbTotal ?? result.length,
+    limit: params?.limit,
+    offset: params?.offset
+  };
+}
+async function getContentItemById(adapter, id, options) {
+  const item = await adapter.findOne({
+    model: "contentItem",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    join: { contentType: true }
+  });
+  if (!item) return null;
+  validateContentReadOptions(item.contentType, options);
+  return applyContentReadOptions(serializeContentItemWithType(item), options);
+}
+async function getContentItemBySlug(adapter, contentTypeSlug, slug, options) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return null;
+  }
+  validateContentReadOptions(contentType, options);
+  const item = await adapter.findOne({
+    model: "contentItem",
+    where: [
+      {
+        field: "contentTypeId",
+        value: contentType.id,
+        operator: "eq"
+      },
+      { field: "slug", value: slug, operator: "eq" }
+    ],
+    join: { contentType: true }
+  });
+  if (!item) {
+    return null;
+  }
+  return applyContentReadOptions(serializeContentItemWithType(item), options);
+}
+async function getContentItemsByRelation(adapter, contentTypeSlug, params) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [{ field: "slug", value: contentTypeSlug, operator: "eq" }]
+  });
+  if (!contentType) {
+    return {
+      items: [],
+      total: 0,
+      limit: params.limit ?? 20,
+      offset: params.offset ?? 0
+    };
+  }
+  validateContentReadOptions(contentType, params);
+  const result = await getContentItemsByRelationForType(
+    adapter,
+    contentType,
+    params
+  );
+  return {
+    ...result,
+    items: result.items.map((item) => applyContentReadOptions(item, params))
+  };
+}
+async function getContentItemsByRelationForType(adapter, contentType, params) {
+  const limit = params.limit ?? 20;
+  const offset = params.offset ?? 0;
+  const batchSize = 100;
+  const sourceIds = /* @__PURE__ */ new Set();
+  for (let relationOffset = 0; ; relationOffset += batchSize) {
+    const relations = await adapter.findMany(
+      {
+        model: "contentRelation",
+        where: [
+          { field: "targetId", value: params.targetId, operator: "eq" },
+          { field: "fieldName", value: params.field, operator: "eq" }
+        ],
+        select: ["sourceId"],
+        limit: batchSize,
+        offset: relationOffset,
+        sortBy: { field: "id", direction: "asc" }
+      }
+    );
+    for (const relation of relations) sourceIds.add(relation.sourceId);
+    if (relations.length < batchSize) break;
+  }
+  const ids = [...sourceIds];
+  const metadata = [];
+  for (let start = 0; start < ids.length; start += batchSize) {
+    metadata.push(
+      ...await adapter.findMany({
+        model: "contentItem",
+        where: [
+          {
+            field: "id",
+            value: ids.slice(start, start + batchSize),
+            operator: "in"
+          },
+          { field: "contentTypeId", value: contentType.id, operator: "eq" }
+        ],
+        select: ["id", "createdAt"],
+        limit: batchSize
+      })
+    );
+  }
+  metadata.sort(
+    (left, right) => right.createdAt.getTime() - left.createdAt.getTime() || (left.id < right.id ? 1 : left.id > right.id ? -1 : 0)
+  );
+  const pageIds = metadata.slice(offset, offset + limit).map((item) => item.id);
+  const itemsById = /* @__PURE__ */ new Map();
+  for (let start = 0; start < pageIds.length; start += batchSize) {
+    const items = await adapter.findMany({
+      model: "contentItem",
+      where: [
+        {
+          field: "id",
+          value: pageIds.slice(start, start + batchSize),
+          operator: "in"
+        },
+        { field: "contentTypeId", value: contentType.id, operator: "eq" }
+      ],
+      limit: batchSize,
+      join: { contentType: true }
+    });
+    for (const item of items) itemsById.set(item.id, item);
+  }
+  return {
+    items: pageIds.flatMap((id) => {
+      const item = itemsById.get(id);
+      return item ? [serializeContentItemWithType(item)] : [];
+    }),
+    total: metadata.length,
+    limit,
+    offset
+  };
+}
+
+exports.CMSContentSelectionError = CMSContentSelectionError;
+exports.applyContentReadOptions = applyContentReadOptions;
+exports.getAllContentItems = getAllContentItems;
+exports.getAllContentTypes = getAllContentTypes;
+exports.getContentItemById = getContentItemById;
+exports.getContentItemBySlug = getContentItemBySlug;
+exports.getContentItemsByRelation = getContentItemsByRelation;
+exports.getContentItemsByRelationForType = getContentItemsByRelationForType;
+exports.migrateToUnifiedSchema = migrateToUnifiedSchema;
+exports.serializeContentItem = serializeContentItem;
+exports.serializeContentItemWithType = serializeContentItemWithType;
+exports.serializeContentType = serializeContentType;
+exports.validateContentReadOptions = validateContentReadOptions;

package/dist/api/getters.mjs

@@ -0,0 +1,314 @@
+import { DEFAULT_MAX_PAGE_SIZE, contentReadOptionsSchema, normalizeContentFields } from '../schemas.mjs';
+
+class CMSContentSelectionError extends Error {
+}
+function validateContentReadOptions(contentType, options) {
+  contentReadOptionsSchema.parse(options ?? {});
+  if (options?.fields === void 0) return;
+  if (options.view !== "content") {
+    throw new CMSContentSelectionError("fields requires view: content");
+  }
+  const properties = contentType ? JSON.parse(contentType.jsonSchema).properties : void 0;
+  for (const field of options.fields) {
+    if (!properties || !Object.hasOwn(properties, field)) {
+      throw new CMSContentSelectionError(
+        `Unknown top-level content field: ${field}`
+      );
+    }
+  }
+}
+function applyContentReadOptions(item, options) {
+  const result = options?.view === "content" ? {
+    id: item.id,
+    slug: item.slug,
+    parsedData: options.fields ? Object.fromEntries(
+      normalizeContentFields(options.fields).filter((field) => Object.hasOwn(item.parsedData, field)).map((field) => [
+        field,
+        item.parsedData[field]
+      ])
+    ) : item.parsedData,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt
+  } : item;
+  return result;
+}
+function serializeContentType(ct) {
+  const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
+  const migratedJsonSchema = needsMigration ? migrateToUnifiedSchema(ct.jsonSchema, ct.fieldConfig) : ct.jsonSchema;
+  return {
+    id: ct.id,
+    name: ct.name,
+    slug: ct.slug,
+    description: ct.description,
+    jsonSchema: migratedJsonSchema,
+    createdAt: ct.createdAt.toISOString(),
+    updatedAt: ct.updatedAt.toISOString()
+  };
+}
+function migrateToUnifiedSchema(jsonSchemaStr, fieldConfigStr) {
+  if (!fieldConfigStr) return jsonSchemaStr;
+  try {
+    const jsonSchema = JSON.parse(jsonSchemaStr);
+    const fieldConfig = JSON.parse(fieldConfigStr);
+    if (!jsonSchema.properties || typeof fieldConfig !== "object") {
+      return jsonSchemaStr;
+    }
+    for (const [key, config] of Object.entries(fieldConfig)) {
+      if (jsonSchema.properties[key] && typeof config === "object" && config !== null && "fieldType" in config) {
+        jsonSchema.properties[key].fieldType = config.fieldType;
+      }
+    }
+    return JSON.stringify(jsonSchema);
+  } catch {
+    return jsonSchemaStr;
+  }
+}
+function serializeContentItem(item) {
+  return {
+    ...item,
+    createdAt: item.createdAt.toISOString(),
+    updatedAt: item.updatedAt.toISOString()
+  };
+}
+function serializeContentItemWithType(item) {
+  const parsedData = JSON.parse(item.data);
+  return {
+    ...serializeContentItem(item),
+    parsedData,
+    contentType: item.contentType ? serializeContentType(item.contentType) : void 0
+  };
+}
+async function getAllContentTypes(adapter) {
+  const contentTypes = await adapter.findMany({
+    model: "contentType",
+    sortBy: { field: "name", direction: "asc" }
+  });
+  return contentTypes.map(serializeContentType);
+}
+function contentItemMatchesSearch(item, searchLower) {
+  if (item.slug.toLowerCase().includes(searchLower)) return true;
+  const matchesValue = (value) => typeof value === "string" && value.toLowerCase().includes(searchLower);
+  return Object.values(item.parsedData).some((value) => {
+    if (matchesValue(value)) return true;
+    if (Array.isArray(value)) return value.some(matchesValue);
+    if (typeof value === "object" && value !== null) {
+      return Object.values(value).some(matchesValue);
+    }
+    return false;
+  });
+}
+async function getAllContentItems(adapter, contentTypeSlug, params) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return {
+      items: [],
+      total: 0,
+      limit: params?.limit,
+      offset: params?.offset
+    };
+  }
+  validateContentReadOptions(contentType, params);
+  const whereConditions = [
+    {
+      field: "contentTypeId",
+      value: contentType.id,
+      operator: "eq"
+    }
+  ];
+  if (params?.slug) {
+    whereConditions.push({
+      field: "slug",
+      value: params.slug,
+      operator: "eq"
+    });
+  }
+  const search = params?.search?.trim();
+  const needsInMemoryFilter = !!search;
+  const dbTotal = !needsInMemoryFilter ? await adapter.count({
+    model: "contentItem",
+    where: whereConditions
+  }) : void 0;
+  const items = await adapter.findMany({
+    model: "contentItem",
+    where: whereConditions,
+    limit: !needsInMemoryFilter ? params?.limit : DEFAULT_MAX_PAGE_SIZE,
+    offset: !needsInMemoryFilter ? params?.offset : void 0,
+    sortBy: { field: "createdAt", direction: "desc" },
+    join: { contentType: true }
+  });
+  let result = items.map(serializeContentItemWithType);
+  if (needsInMemoryFilter) {
+    const searchLower = search.toLowerCase();
+    result = result.filter(
+      (item) => contentItemMatchesSearch(item, searchLower)
+    );
+    const total = result.length;
+    const offset = params?.offset ?? 0;
+    const limit = params?.limit;
+    result = result.slice(
+      offset,
+      limit !== void 0 ? offset + limit : void 0
+    );
+    return {
+      items: result.map((item) => applyContentReadOptions(item, params)),
+      total,
+      limit: params?.limit,
+      offset: params?.offset
+    };
+  }
+  return {
+    items: result.map((item) => applyContentReadOptions(item, params)),
+    total: dbTotal ?? result.length,
+    limit: params?.limit,
+    offset: params?.offset
+  };
+}
+async function getContentItemById(adapter, id, options) {
+  const item = await adapter.findOne({
+    model: "contentItem",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    join: { contentType: true }
+  });
+  if (!item) return null;
+  validateContentReadOptions(item.contentType, options);
+  return applyContentReadOptions(serializeContentItemWithType(item), options);
+}
+async function getContentItemBySlug(adapter, contentTypeSlug, slug, options) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return null;
+  }
+  validateContentReadOptions(contentType, options);
+  const item = await adapter.findOne({
+    model: "contentItem",
+    where: [
+      {
+        field: "contentTypeId",
+        value: contentType.id,
+        operator: "eq"
+      },
+      { field: "slug", value: slug, operator: "eq" }
+    ],
+    join: { contentType: true }
+  });
+  if (!item) {
+    return null;
+  }
+  return applyContentReadOptions(serializeContentItemWithType(item), options);
+}
+async function getContentItemsByRelation(adapter, contentTypeSlug, params) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [{ field: "slug", value: contentTypeSlug, operator: "eq" }]
+  });
+  if (!contentType) {
+    return {
+      items: [],
+      total: 0,
+      limit: params.limit ?? 20,
+      offset: params.offset ?? 0
+    };
+  }
+  validateContentReadOptions(contentType, params);
+  const result = await getContentItemsByRelationForType(
+    adapter,
+    contentType,
+    params
+  );
+  return {
+    ...result,
+    items: result.items.map((item) => applyContentReadOptions(item, params))
+  };
+}
+async function getContentItemsByRelationForType(adapter, contentType, params) {
+  const limit = params.limit ?? 20;
+  const offset = params.offset ?? 0;
+  const batchSize = 100;
+  const sourceIds = /* @__PURE__ */ new Set();
+  for (let relationOffset = 0; ; relationOffset += batchSize) {
+    const relations = await adapter.findMany(
+      {
+        model: "contentRelation",
+        where: [
+          { field: "targetId", value: params.targetId, operator: "eq" },
+          { field: "fieldName", value: params.field, operator: "eq" }
+        ],
+        select: ["sourceId"],
+        limit: batchSize,
+        offset: relationOffset,
+        sortBy: { field: "id", direction: "asc" }
+      }
+    );
+    for (const relation of relations) sourceIds.add(relation.sourceId);
+    if (relations.length < batchSize) break;
+  }
+  const ids = [...sourceIds];
+  const metadata = [];
+  for (let start = 0; start < ids.length; start += batchSize) {
+    metadata.push(
+      ...await adapter.findMany({
+        model: "contentItem",
+        where: [
+          {
+            field: "id",
+            value: ids.slice(start, start + batchSize),
+            operator: "in"
+          },
+          { field: "contentTypeId", value: contentType.id, operator: "eq" }
+        ],
+        select: ["id", "createdAt"],
+        limit: batchSize
+      })
+    );
+  }
+  metadata.sort(
+    (left, right) => right.createdAt.getTime() - left.createdAt.getTime() || (left.id < right.id ? 1 : left.id > right.id ? -1 : 0)
+  );
+  const pageIds = metadata.slice(offset, offset + limit).map((item) => item.id);
+  const itemsById = /* @__PURE__ */ new Map();
+  for (let start = 0; start < pageIds.length; start += batchSize) {
+    const items = await adapter.findMany({
+      model: "contentItem",
+      where: [
+        {
+          field: "id",
+          value: pageIds.slice(start, start + batchSize),
+          operator: "in"
+        },
+        { field: "contentTypeId", value: contentType.id, operator: "eq" }
+      ],
+      limit: batchSize,
+      join: { contentType: true }
+    });
+    for (const item of items) itemsById.set(item.id, item);
+  }
+  return {
+    items: pageIds.flatMap((id) => {
+      const item = itemsById.get(id);
+      return item ? [serializeContentItemWithType(item)] : [];
+    }),
+    total: metadata.length,
+    limit,
+    offset
+  };
+}
+
+export { CMSContentSelectionError, applyContentReadOptions, getAllContentItems, getAllContentTypes, getContentItemById, getContentItemBySlug, getContentItemsByRelation, getContentItemsByRelationForType, migrateToUnifiedSchema, serializeContentItem, serializeContentItemWithType, serializeContentType, validateContentReadOptions };

package/dist/api/index.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const plugin = require('./plugin.cjs');
+const getters = require('./getters.cjs');
+const mutations = require('./mutations.cjs');
+const queryKeyDefs = require('./query-key-defs.cjs');
+const queryKeys = require('../query-keys.cjs');
+const operations = require('./operations.cjs');
+const lifecycleMigrations = require('./lifecycle-migrations.cjs');
+
+
+
+exports.cmsBackendPlugin = plugin.cmsBackendPlugin;
+exports.getAllContentItems = getters.getAllContentItems;
+exports.getAllContentTypes = getters.getAllContentTypes;
+exports.getContentItemById = getters.getContentItemById;
+exports.getContentItemBySlug = getters.getContentItemBySlug;
+exports.getContentItemsByRelation = getters.getContentItemsByRelation;
+exports.serializeContentItem = getters.serializeContentItem;
+exports.serializeContentItemWithType = getters.serializeContentItemWithType;
+exports.serializeContentType = getters.serializeContentType;
+exports.createCMSContentItem = mutations.createCMSContentItem;
+exports.CMS_QUERY_KEYS = queryKeyDefs.CMS_QUERY_KEYS;
+exports.createCMSQueryKeys = queryKeys.createCMSQueryKeys;
+exports.CMSContentItemParamsSchema = operations.CMSContentItemParamsSchema;
+exports.CMSContentTypeParamsSchema = operations.CMSContentTypeParamsSchema;
+exports.CMSCreateContentItemBodySchema = operations.CMSCreateContentItemBodySchema;
+exports.CMSUpdateContentItemBodySchema = operations.CMSUpdateContentItemBodySchema;
+exports.CMS_LIFECYCLE_HOOK_MIGRATIONS = lifecycleMigrations.CMS_LIFECYCLE_HOOK_MIGRATIONS;