dineway 0.2.40 → 0.2.41

package/dist/client/index.d.mts

@@ -1,16 +1,19 @@
-import { Ms as ReviewRequestStatus, Wt as PublicationPolicyOverride, Yt as PublicationReadinessResult, Zt as PublicationReceipt, js as ReviewRequest } from "../types-D5JfvPvx.mjs";
-import "../types-B--VyN3n.mjs";
-import "../runner-SoP1rphP.mjs";
-import "../index-BVGe04wF.mjs";
-import "../types-B03h5jt_.mjs";
-import "../adapters-C8nRpUuj.mjs";
-import "../scheduled-publish-BxdShRGs.mjs";
-import "../public-url-Ccv0Xmue.mjs";
-import "../validate-kmN2lS8H.mjs";
-import "../byline-fields-D-b9CWux.mjs";
-import "../types-DsJTXStN.mjs";
-import { a as tokenInterceptor, i as devBypassInterceptor, n as createTransport, r as csrfInterceptor, t as Interceptor } from "../transport-CZbtxgKZ.mjs";
-import { n as markdownToPortableText, r as portableTextToMarkdown, t as PortableTextBlock } from "../portable-text-BE7nszX6.mjs";
+import { Ms as ReviewRequestStatus, Wt as PublicationPolicyOverride, Yt as PublicationReadinessResult, Zt as PublicationReceipt, js as ReviewRequest } from "../types-C3jUu4Bc.mjs";
+import "../types-Dpv_MvwZ.mjs";
+import "../runner-DXQkyPeX.mjs";
+import "../index-CLj17kW9.mjs";
+import "../types-qOEot0UQ.mjs";
+import "../types-DheoByey.mjs";
+import "../adapters-lDnJjNDz.mjs";
+import "../runtime-Bs2JMbb2.mjs";
+import "../hook-events-BQw73jc7.mjs";
+import "../scheduled-publish-eCNGpvNm.mjs";
+import "../public-url-CEC1vj02.mjs";
+import "../validate-DUscf6VG.mjs";
+import "../byline-fields-Bne2v0ti.mjs";
+import "../types-BJztoTbF.mjs";
+import { a as tokenInterceptor, i as devBypassInterceptor, n as createTransport, r as csrfInterceptor, t as Interceptor } from "../transport-CVU5rp7W.mjs";
+import { n as markdownToPortableText, r as portableTextToMarkdown, t as PortableTextBlock } from "../portable-text-HNmwL-7L.mjs";
 
 //#region src/client/index.d.ts
 interface DinewayClientOptions {

package/dist/client/index.mjs

@@ -1,5 +1,5 @@
-import { i as portableTextToMarkdown, n as convertDataForWrite, r as markdownToPortableText, t as convertDataForRead } from "../portable-text-tQhvPLf1.mjs";
-import { a as tokenInterceptor, i as refreshInterceptor, n as csrfInterceptor, r as devBypassInterceptor, t as createTransport } from "../transport-BrU1aDY5.mjs";
+import { i as portableTextToMarkdown, n as convertDataForWrite, r as markdownToPortableText, t as convertDataForRead } from "../portable-text-CSbRjM-T.mjs";
+import { a as tokenInterceptor, i as refreshInterceptor, n as csrfInterceptor, r as devBypassInterceptor, t as createTransport } from "../transport-BHYE4pox.mjs";
 import mime from "mime/lite";
 
 //#region src/client/index.ts

package/dist/{client-factory-C1ZQCMog.mjs → client-factory-BLbm250o.mjs}

@@ -1,4 +1,4 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
 import { customHeadersInterceptor, resolveCustomHeaders } from "./client/external-auth-headers.mjs";
 import { DinewayClient } from "./client/index.mjs";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";

package/dist/{comment-DAQfUjqt.mjs → comment-BWDG1nQm.mjs}

@@ -1,5 +1,5 @@
-import { i as encodeCursor, r as decodeCursor } from "./types-RFzE_V1M.mjs";
-import { s as invalidateCommentObjectCache } from "./object-cache-mxCW-Rpt.mjs";
+import { i as encodeCursor, r as decodeCursor } from "./types-BI3ULB3A.mjs";
+import { s as invalidateCommentObjectCache } from "./object-cache-DyI1SOBK.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 

package/dist/{comment-reaction-Dp3G7UZc.mjs → comment-reaction-B7pLTlQ7.mjs}

@@ -1,4 +1,4 @@
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C8vSD_5L.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Bb56aCtB.mjs";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/comment-reaction.ts

package/dist/{comments-BrvIaRAx.mjs → comments-xkten8nV.mjs}

@@ -1,4 +1,4 @@
-import { t as CommentRepository } from "./comment-DAQfUjqt.mjs";
+import { t as CommentRepository } from "./comment-BWDG1nQm.mjs";
 
 //#region src/api/handlers/comments.ts
 async function handleCommentList(db, collection, contentId, options = {}) {

package/dist/config-6R0bchVE.mjs

@@ -0,0 +1,125 @@
+import { z } from "zod";
+
+//#region src/content-storage/types.ts
+/** Prepared writes must not replay other business statements after this operation committed. */
+var ContentStorageReplay = class extends Error {
+	constructor(location) {
+		super("This content operation has already committed.");
+		this.location = location;
+		this.name = "ContentStorageReplay";
+	}
+};
+var ContentStorageError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ContentStorageError";
+	}
+};
+
+//#endregion
+//#region src/content-storage/config.ts
+const contentStorageConfigSchema = z.object({
+	version: z.string(),
+	stores: z.record(z.string(), z.object({
+		provider: z.literal("d1"),
+		entrypoint: z.string(),
+		identity: z.string(),
+		config: z.record(z.string(), z.json())
+	}).strict()),
+	rules: z.record(z.string(), z.object({
+		partitionBy: z.union([z.object({ field: z.string() }).strict(), z.object({
+			entrypoint: z.string(),
+			config: z.json().optional(),
+			taxonomies: z.array(z.string()).optional(),
+			references: z.record(z.string(), z.object({
+				collection: z.string(),
+				taxonomies: z.array(z.string()).optional()
+			}).strict()).optional()
+		}).strict()]),
+		stores: z.record(z.string(), z.string())
+	}).strict())
+}).strict();
+const NAME = /^[a-z][a-z0-9_-]{0,62}$/;
+const COLLECTION = /^[a-z][a-z0-9_]{0,62}$/;
+const FIELD = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/;
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function invalid(message) {
+	throw new ContentStorageError("INVALID_CONFIG", message);
+}
+function canonicalContentJson(value) {
+	const visit = (input) => {
+		if (input === null || typeof input === "string" || typeof input === "boolean") return input;
+		if (typeof input === "number" && Number.isFinite(input)) return input;
+		if (Array.isArray(input)) return input.map(visit);
+		if (typeof input !== "object" || input === null || Object.getPrototypeOf(input) !== Object.prototype) return invalid("Content storage values must be finite JSON values.");
+		return Object.fromEntries(Object.entries(input).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => {
+			if (UNSAFE_KEYS.has(key)) invalid(`Unsafe content storage key: ${key}`);
+			return [key, visit(child)];
+		}));
+	};
+	return JSON.stringify(visit(value));
+}
+async function contentDigest(value) {
+	const bytes = new TextEncoder().encode(canonicalContentJson(value));
+	const digest = await crypto.subtle.digest("SHA-256", bytes);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function validateContentStorage(config) {
+	if (!config.version || config.version.length > 128) invalid("Content storage requires a routing version of at most 128 characters.");
+	canonicalContentJson(config);
+	const identities = /* @__PURE__ */ new Set();
+	for (const [name, store] of Object.entries(config.stores)) {
+		if (!NAME.test(name) || name === "primary" || UNSAFE_KEYS.has(name)) invalid(`Invalid content store name: ${name}`);
+		if (store.provider !== "d1" || !store.entrypoint || !store.identity) invalid(`Content store ${name} requires a D1 adapter and physical identity.`);
+		if (identities.has(store.identity)) invalid("Each content store must identify a distinct physical database.");
+		identities.add(store.identity);
+	}
+	for (const [collection, rule] of Object.entries(config.rules)) {
+		if (!COLLECTION.test(collection) || UNSAFE_KEYS.has(collection)) invalid(`Invalid content type: ${collection}`);
+		if ("field" in rule.partitionBy) {
+			if (!FIELD.test(rule.partitionBy.field) || rule.partitionBy.field.split(".").some((part) => UNSAFE_KEYS.has(part))) invalid(`Invalid partition field for ${collection}`);
+		} else {
+			if (!rule.partitionBy.entrypoint) invalid(`Content type ${collection} requires a partition resolver entrypoint.`);
+			const names = [...rule.partitionBy.taxonomies ?? []];
+			for (const [field, reference] of Object.entries(rule.partitionBy.references ?? {})) {
+				if (!COLLECTION.test(field) || UNSAFE_KEYS.has(field) || !COLLECTION.test(reference.collection) || UNSAFE_KEYS.has(reference.collection)) invalid(`Invalid partition reference for ${collection}.`);
+				names.push(...reference.taxonomies ?? []);
+			}
+			if (names.length > 16 || Object.keys(rule.partitionBy.references ?? {}).length > 8 || names.some((name) => !COLLECTION.test(name) || UNSAFE_KEYS.has(name))) invalid(`Invalid or excessive partition dependencies for ${collection}.`);
+		}
+		if (!Object.keys(rule.stores).length) invalid(`Content type ${collection} requires a partition mapping.`);
+		for (const [partition, store] of Object.entries(rule.stores)) if (!partition || partition.length > 256 || store !== "primary" && !Object.hasOwn(config.stores, store)) invalid(`Unknown content store for ${collection}/${partition}`);
+	}
+}
+async function resolveContentPartition(config, context, resolvers = {}) {
+	if (!Object.hasOwn(config.rules, context.collection)) return null;
+	const rule = config.rules[context.collection];
+	let value;
+	if ("field" in rule.partitionBy) {
+		value = context.data;
+		for (const part of rule.partitionBy.field.split(".")) value = typeof value === "object" && value !== null && Object.hasOwn(value, part) ? Reflect.get(value, part) : void 0;
+	} else {
+		const resolver = resolvers[context.collection];
+		if (!resolver) throw new ContentStorageError("INVALID_CONFIG", `Partition resolver is not loaded for ${context.collection}.`);
+		const metadata = context.data._dineway;
+		const dependencies = metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata.partitionDependencies : void 0;
+		value = await resolver({
+			...context,
+			dependencies: context.dependencies ?? (dependencies && typeof dependencies === "object" && !Array.isArray(dependencies) ? dependencies : void 0)
+		}, rule.partitionBy.config);
+	}
+	const partition = typeof value === "string" ? value : typeof value === "number" && Number.isFinite(value) ? String(value) : "";
+	if (!partition || !Object.hasOwn(rule.stores, partition)) throw new ContentStorageError("INVALID_PARTITION", `No content store is configured for ${context.collection}'s partition.`);
+	return {
+		store: rule.stores[partition],
+		partition
+	};
+}
+
+//#endregion
+export { validateContentStorage as a, resolveContentPartition as i, contentDigest as n, ContentStorageError as o, contentStorageConfigSchema as r, ContentStorageReplay as s, canonicalContentJson as t };