dineway 0.1.3

package/dist/astro/types.d.mts

@@ -0,0 +1,269 @@
+import { f as MediaProvider, p as MediaProviderCapabilities } from "../placeholder-bOx1xCTY.mjs";
+import { t as Database } from "../types-DkvMXalq.mjs";
+import { Cn as DinewayConfig, Xi as ContentResponse, Yi as ContentListResponse, _i as MediaResponse, _n as EmailPipeline, gi as MediaListResponse, la as MediaItem, ni as SandboxRunner, vn as HookPipeline } from "../index-C-jx21qs.mjs";
+import "../runner-B5l1JfOj.mjs";
+import { r as ContentItem } from "../types-CLLdsG3g.mjs";
+import { G as PublicPageContext, J as ResolvedPlugin, O as PageMetadataContribution, T as PageFragmentContribution, at as Element } from "../types-D38djUXv.mjs";
+import "../validate-DVKJJ-M_.mjs";
+import { d as Storage } from "../types-ju-_ORz7.mjs";
+import "../index.mjs";
+import { Kysely } from "kysely";
+
+//#region src/astro/types.d.ts
+/**
+ * Manifest collection definition
+ */
+interface ManifestCollection {
+  label: string;
+  labelSingular: string;
+  supports: string[];
+  hasSeo: boolean;
+  urlPattern?: string;
+  fields: Record<string, {
+    kind: string;
+    label?: string;
+    required?: boolean;
+    widget?: string;
+    /**
+     * Field options. Two shapes:
+     *   - Legacy enum: `Array<{ value, label }>` for select / multiSelect widgets
+     *   - Plugin widgets: `Record<string, unknown>` for arbitrary per-field config
+     *     (e.g. a checkbox grid receiving its column definitions)
+     */
+    options?: Array<{
+      value: string;
+      label: string;
+    }> | Record<string, unknown>;
+  }>;
+}
+/**
+ * Plugin manifest entry in the admin manifest
+ */
+interface ManifestPlugin {
+  version?: string;
+  /** Package name for dynamic import (e.g., "@dineway-ai/plugin-audit-log") */
+  package?: string;
+  /** Whether the plugin is currently enabled */
+  enabled?: boolean;
+  /**
+   * How this plugin renders its admin UI:
+   * - "react": Trusted plugin with React components (default for trusted plugins)
+   * - "blocks": Declarative Block Kit UI via admin route handler
+   * - "none": No admin UI
+   */
+  adminMode?: "react" | "blocks" | "none";
+  adminPages?: Array<{
+    path: string;
+    label?: string;
+    icon?: string;
+  }>;
+  dashboardWidgets?: Array<{
+    id: string;
+    title?: string;
+    size?: string;
+  }>;
+  fieldWidgets?: Array<{
+    name: string;
+    label: string;
+    fieldTypes: string[];
+    elements?: Element[];
+  }>;
+  /** Portable Text block types provided by this plugin */
+  portableTextBlocks?: Array<{
+    type: string;
+    label: string;
+    icon?: string;
+    description?: string;
+    placeholder?: string;
+    fields?: Element[];
+  }>;
+}
+/**
+ * Auth mode indicator for the admin UI
+ * - "passkey": Built-in passkey authentication (default)
+ * - string: External auth provider type (e.g., "header-auth")
+ */
+type ManifestAuthMode = string;
+/**
+ * The Dineway manifest provided to the admin UI
+ */
+interface DinewayManifest {
+  version: string;
+  hash: string;
+  collections: Record<string, ManifestCollection>;
+  plugins: Record<string, ManifestPlugin>;
+  /**
+   * Auth mode for the admin UI. When "passkey", the security settings
+   * (passkey management, self-signup domains) are shown. Any other
+   * value is treated as external auth, so those settings stay hidden.
+   */
+  authMode: ManifestAuthMode;
+  /**
+   * Whether self-signup is enabled (at least one allowed domain is active).
+   * Used by the login page to conditionally show the "Sign up" link.
+   */
+  signupEnabled?: boolean;
+  /**
+   * i18n configuration from Astro config.
+   * Only present when i18n is enabled (multiple locales configured).
+   */
+  i18n?: {
+    defaultLocale: string;
+    locales: string[];
+    prefixDefaultLocale?: boolean;
+  };
+  /**
+   * Taxonomy definitions for the admin sidebar.
+   */
+  taxonomies: Array<{
+    name: string;
+    label: string;
+    labelSingular?: string;
+    hierarchical: boolean;
+    collections: string[];
+  }>;
+  /**
+   * Whether the plugin marketplace is configured.
+   * When true, the admin UI can show marketplace browse/install features.
+   */
+  marketplace?: boolean;
+}
+/**
+ * Standard handler response shape used by all DinewayHandlers methods.
+ *
+ * The error shape matches `ApiResult` from the core package — typing it
+ * here lets route files use `result.error?.code` without unsafe casts while
+ * keeping the data side loosely coupled (defaults to `unknown`).
+ */
+interface HandlerResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+  };
+}
+/**
+ * The Dineway API handlers provided via Astro.locals
+ *
+ * Data types default to `unknown` to avoid tight coupling with the core
+ * package. Handlers whose data shape is accessed in route files (e.g.
+ * handleContentGet, handleRevisionGet) use narrower types.
+ */
+interface DinewayHandlers {
+  handleContentList: (collection: string, params: {
+    cursor?: string;
+    limit?: number;
+    status?: string;
+    orderBy?: string;
+    order?: "asc" | "desc";
+    locale?: string;
+  }) => Promise<HandlerResponse>;
+  handleContentGet: (collection: string, id: string, locale?: string) => Promise<HandlerResponse<{
+    item: {
+      id: string;
+      authorId: string | null;
+      [key: string]: unknown;
+    };
+    _rev?: string;
+  }>>;
+  handleContentCreate: (collection: string, body: {
+    data: Record<string, unknown>;
+    slug?: string;
+    status?: string;
+    authorId?: string;
+    locale?: string;
+    translationOf?: string;
+    createdAt?: string | null;
+    publishedAt?: string | null;
+  }) => Promise<HandlerResponse>;
+  handleContentUpdate: (collection: string, id: string, body: {
+    data?: Record<string, unknown>;
+    slug?: string;
+    status?: string;
+    authorId?: string | null;
+    _rev?: string;
+  }) => Promise<HandlerResponse>;
+  handleContentDelete: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentListTrashed: (collection: string, params?: {
+    cursor?: string;
+    limit?: number;
+  }) => Promise<HandlerResponse>;
+  handleContentRestore: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentPermanentDelete: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentCountTrashed: (collection: string) => Promise<HandlerResponse>;
+  handleContentGetIncludingTrashed: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentDuplicate: (collection: string, id: string, authorId?: string) => Promise<HandlerResponse>;
+  handleContentPublish: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentUnpublish: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentSchedule: (collection: string, id: string, scheduledAt: string) => Promise<HandlerResponse>;
+  handleContentUnschedule: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentCountScheduled: (collection: string) => Promise<HandlerResponse>;
+  handleContentDiscardDraft: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentCompare: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleContentTranslations: (collection: string, id: string) => Promise<HandlerResponse>;
+  handleMediaList: (params: {
+    cursor?: string;
+    limit?: number;
+    mimeType?: string;
+  }) => Promise<HandlerResponse>;
+  handleMediaGet: (id: string) => Promise<HandlerResponse>;
+  handleMediaCreate: (input: {
+    filename: string;
+    mimeType: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    storageKey: string;
+    contentHash?: string;
+    blurhash?: string;
+    dominantColor?: string;
+    authorId?: string;
+  }) => Promise<HandlerResponse>;
+  handleMediaUpdate: (id: string, input: {
+    alt?: string;
+    caption?: string;
+    width?: number;
+    height?: number;
+  }) => Promise<HandlerResponse>;
+  handleMediaDelete: (id: string) => Promise<HandlerResponse>;
+  handleRevisionList: (collection: string, entryId: string, params?: {
+    limit?: number;
+  }) => Promise<HandlerResponse>;
+  handleRevisionGet: (revisionId: string) => Promise<HandlerResponse<{
+    item: {
+      id: string;
+      collection: string;
+      entryId: string;
+      authorId: string | null;
+      [key: string]: unknown;
+    };
+  }>>;
+  handleRevisionRestore: (revisionId: string, callerUserId: string) => Promise<HandlerResponse>;
+  handlePluginApiRoute: (pluginId: string, method: string, path: string, request: Request) => Promise<HandlerResponse>;
+  getPluginRouteMeta: (pluginId: string, path: string) => {
+    public: boolean;
+  } | null;
+  getMediaProvider: (providerId: string) => MediaProvider | undefined;
+  getMediaProviderList: () => Array<{
+    id: string;
+    name: string;
+    icon?: string;
+    capabilities: MediaProviderCapabilities;
+  }>;
+  storage: Storage | null;
+  db: Kysely<Database>;
+  hooks: HookPipeline;
+  email: EmailPipeline | null;
+  configuredPlugins: ResolvedPlugin[];
+  config: DinewayConfig;
+  invalidateManifest: () => void;
+  getSandboxRunner: () => SandboxRunner | null;
+  syncMarketplacePlugins: () => Promise<void>;
+  setPluginStatus: (pluginId: string, status: "active" | "inactive") => Promise<void>;
+  collectPageMetadata: (page: PublicPageContext) => Promise<PageMetadataContribution[]>;
+  collectPageFragments: (page: PublicPageContext) => Promise<PageFragmentContribution[]>;
+}
+//#endregion
+export { type ContentItem, type ContentListResponse, type ContentResponse, type Database, DinewayHandlers, DinewayManifest, HandlerResponse, ManifestAuthMode, ManifestCollection, ManifestPlugin, type MediaItem, type MediaListResponse, type MediaResponse, type Storage };

package/dist/astro/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/base64-F8-DUraK.mjs

@@ -0,0 +1,58 @@
+//#region src/utils/base64.ts
+/**
+* Base64 encoding/decoding utilities.
+*
+* Uses native Uint8Array.prototype.toBase64 / Uint8Array.fromBase64 when
+* available in newer runtimes, falls back to btoa/atob.
+*
+* All base64url encoding uses the { alphabet: "base64url" } option natively
+* or manual character replacement as fallback.
+*
+* Delete the fallback paths when the minimum Node version supports these
+* methods natively.
+*/
+const hasNative = typeof Uint8Array.prototype.toBase64 === "function" && typeof Uint8Array.fromBase64 === "function";
+const BASE64_PLUS_PATTERN = /\+/g;
+const BASE64_SLASH_PATTERN = /\//g;
+const BASE64_PADDING_PATTERN = /=+$/;
+const BASE64URL_DASH_PATTERN = /-/g;
+const BASE64URL_UNDERSCORE_PATTERN = /_/g;
+/** Encode a UTF-8 string as standard base64. */
+function encodeBase64(str) {
+	const bytes = new TextEncoder().encode(str);
+	if (hasNative) return bytes.toBase64();
+	let binary = "";
+	for (const b of bytes) binary += String.fromCharCode(b);
+	return btoa(binary);
+}
+/** Decode a standard base64 string to a UTF-8 string. */
+function decodeBase64(base64) {
+	if (hasNative) return new TextDecoder().decode(Uint8Array.fromBase64(base64));
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+/** Encode bytes as base64url without padding. */
+function encodeBase64url(bytes) {
+	if (hasNative) return bytes.toBase64({
+		alphabet: "base64url",
+		omitPadding: true
+	});
+	let binary = "";
+	for (const b of bytes) binary += String.fromCharCode(b);
+	return btoa(binary).replace(BASE64_PLUS_PATTERN, "-").replace(BASE64_SLASH_PATTERN, "_").replace(BASE64_PADDING_PATTERN, "");
+}
+/** Decode a base64url string (with or without padding) to bytes. */
+function decodeBase64url(encoded) {
+	if (hasNative) return Uint8Array.fromBase64(encoded, { alphabet: "base64url" });
+	const base64 = encoded.replace(BASE64URL_DASH_PATTERN, "+").replace(BASE64URL_UNDERSCORE_PATTERN, "/");
+	const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+	const binary = atob(padded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+
+//#endregion
+export { encodeBase64url as i, decodeBase64url as n, encodeBase64 as r, decodeBase64 as t };

package/dist/byline-DeWCMU_i.mjs

@@ -0,0 +1,234 @@
+import { s as listTablesLike } from "./dialect-helpers-B9uSp2GJ.mjs";
+import { t as validateIdentifier } from "./validate-CqRJb_xU.mjs";
+import { n as decodeCursor, r as encodeCursor } from "./types-BawVha09.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/utils/chunks.ts
+/**
+* Split an array into chunks of at most `size` elements.
+*
+* Used to keep SQL `IN (?, ?, …)` clauses within conservative
+* SQLite/libSQL bound-parameter limits.
+*/
+function chunks(arr, size) {
+	if (arr.length === 0) return [];
+	const result = [];
+	for (let i = 0; i < arr.length; i += size) result.push(arr.slice(i, i + size));
+	return result;
+}
+/** Conservative default chunk size for SQL IN clauses on SQLite-compatible adapters. */
+const SQL_BATCH_SIZE = 50;
+
+//#endregion
+//#region src/database/repositories/byline.ts
+function rowToByline(row) {
+	return {
+		id: row.id,
+		slug: row.slug,
+		displayName: row.display_name,
+		bio: row.bio,
+		avatarMediaId: row.avatar_media_id,
+		websiteUrl: row.website_url,
+		userId: row.user_id,
+		isGuest: row.is_guest === 1,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+var BylineRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_bylines").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToByline(row) : null;
+	}
+	async findBySlug(slug) {
+		const row = await this.db.selectFrom("_dineway_bylines").selectAll().where("slug", "=", slug).executeTakeFirst();
+		return row ? rowToByline(row) : null;
+	}
+	async findByUserId(userId) {
+		const row = await this.db.selectFrom("_dineway_bylines").selectAll().where("user_id", "=", userId).executeTakeFirst();
+		return row ? rowToByline(row) : null;
+	}
+	async findMany(options) {
+		const limit = Math.min(Math.max(options?.limit ?? 50, 1), 100);
+		let query = this.db.selectFrom("_dineway_bylines").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (options?.search) {
+			const term = `%${options.search.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+			query = query.where((eb) => eb.or([eb("display_name", "like", term), eb("slug", "like", term)]));
+		}
+		if (options?.isGuest !== void 0) query = query.where("is_guest", "=", options.isGuest ? 1 : 0);
+		if (options?.userId !== void 0) query = query.where("user_id", "=", options.userId);
+		if (options?.cursor) {
+			const decoded = decodeCursor(options.cursor);
+			if (decoded) query = query.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		const rows = await query.execute();
+		const items = rows.slice(0, limit).map(rowToByline);
+		const result = { items };
+		if (rows.length > limit) {
+			const last = items.at(-1);
+			if (last) result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async create(input) {
+		const id = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_bylines").values({
+			id,
+			slug: input.slug,
+			display_name: input.displayName,
+			bio: input.bio ?? null,
+			avatar_media_id: input.avatarMediaId ?? null,
+			website_url: input.websiteUrl ?? null,
+			user_id: input.userId ?? null,
+			is_guest: input.isGuest ? 1 : 0,
+			created_at: now,
+			updated_at: now
+		}).execute();
+		const byline = await this.findById(id);
+		if (!byline) throw new Error("Failed to create byline");
+		return byline;
+	}
+	async update(id, input) {
+		if (!await this.findById(id)) return null;
+		const updates = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+		if (input.slug !== void 0) updates.slug = input.slug;
+		if (input.displayName !== void 0) updates.display_name = input.displayName;
+		if (input.bio !== void 0) updates.bio = input.bio;
+		if (input.avatarMediaId !== void 0) updates.avatar_media_id = input.avatarMediaId;
+		if (input.websiteUrl !== void 0) updates.website_url = input.websiteUrl;
+		if (input.userId !== void 0) updates.user_id = input.userId;
+		if (input.isGuest !== void 0) updates.is_guest = input.isGuest ? 1 : 0;
+		await this.db.updateTable("_dineway_bylines").set(updates).where("id", "=", id).execute();
+		return await this.findById(id);
+	}
+	async delete(id) {
+		if (!await this.findById(id)) return false;
+		await this.db.transaction().execute(async (trx) => {
+			await trx.deleteFrom("_dineway_content_bylines").where("byline_id", "=", id).execute();
+			await trx.deleteFrom("_dineway_bylines").where("id", "=", id).execute();
+			const tableNames = await listTablesLike(trx, "ec_%");
+			for (const tableName of tableNames) {
+				validateIdentifier(tableName, "content table");
+				await sql`
+					UPDATE ${sql.ref(tableName)}
+					SET primary_byline_id = NULL
+					WHERE primary_byline_id = ${id}
+				`.execute(trx);
+			}
+		});
+		return true;
+	}
+	async getContentBylines(collectionSlug, contentId) {
+		return (await this.db.selectFrom("_dineway_content_bylines as cb").innerJoin("_dineway_bylines as b", "b.id", "cb.byline_id").select([
+			"cb.sort_order as sort_order",
+			"cb.role_label as role_label",
+			"b.id as id",
+			"b.slug as slug",
+			"b.display_name as display_name",
+			"b.bio as bio",
+			"b.avatar_media_id as avatar_media_id",
+			"b.website_url as website_url",
+			"b.user_id as user_id",
+			"b.is_guest as is_guest",
+			"b.created_at as created_at",
+			"b.updated_at as updated_at"
+		]).where("cb.collection_slug", "=", collectionSlug).where("cb.content_id", "=", contentId).orderBy("cb.sort_order", "asc").execute()).map((row) => ({
+			byline: rowToByline(row),
+			sortOrder: row.sort_order,
+			roleLabel: row.role_label
+		}));
+	}
+	/**
+	* Batch-fetch byline credits for multiple content items in a single query.
+	* Returns a Map keyed by contentId.
+	*/
+	async getContentBylinesMany(collectionSlug, contentIds) {
+		const result = /* @__PURE__ */ new Map();
+		if (contentIds.length === 0) return result;
+		const uniqueContentIds = [...new Set(contentIds)];
+		for (const chunk of chunks(uniqueContentIds, SQL_BATCH_SIZE)) {
+			const rows = await this.db.selectFrom("_dineway_content_bylines as cb").innerJoin("_dineway_bylines as b", "b.id", "cb.byline_id").select([
+				"cb.content_id as content_id",
+				"cb.sort_order as sort_order",
+				"cb.role_label as role_label",
+				"b.id as id",
+				"b.slug as slug",
+				"b.display_name as display_name",
+				"b.bio as bio",
+				"b.avatar_media_id as avatar_media_id",
+				"b.website_url as website_url",
+				"b.user_id as user_id",
+				"b.is_guest as is_guest",
+				"b.created_at as created_at",
+				"b.updated_at as updated_at"
+			]).where("cb.collection_slug", "=", collectionSlug).where("cb.content_id", "in", chunk).orderBy("cb.sort_order", "asc").execute();
+			for (const row of rows) {
+				const contentId = row.content_id;
+				const credit = {
+					byline: rowToByline(row),
+					sortOrder: row.sort_order,
+					roleLabel: row.role_label
+				};
+				const existing = result.get(contentId);
+				if (existing) existing.push(credit);
+				else result.set(contentId, [credit]);
+			}
+		}
+		return result;
+	}
+	/**
+	* Batch-fetch byline profiles linked to user IDs in a single query.
+	* Returns a Map keyed by userId.
+	*/
+	async findByUserIds(userIds) {
+		const result = /* @__PURE__ */ new Map();
+		if (userIds.length === 0) return result;
+		for (const chunk of chunks(userIds, SQL_BATCH_SIZE)) {
+			const rows = await this.db.selectFrom("_dineway_bylines").selectAll().where("user_id", "in", chunk).execute();
+			for (const row of rows) if (row.user_id) result.set(row.user_id, rowToByline(row));
+		}
+		return result;
+	}
+	async setContentBylines(collectionSlug, contentId, inputBylines) {
+		validateIdentifier(collectionSlug, "collection slug");
+		const tableName = `ec_${collectionSlug}`;
+		validateIdentifier(tableName, "content table");
+		const seen = /* @__PURE__ */ new Set();
+		const bylines = inputBylines.filter((item) => {
+			if (seen.has(item.bylineId)) return false;
+			seen.add(item.bylineId);
+			return true;
+		});
+		if (bylines.length > 0) {
+			const ids = bylines.map((item) => item.bylineId);
+			if ((await this.db.selectFrom("_dineway_bylines").select("id").where("id", "in", ids).execute()).length !== ids.length) throw new Error("One or more byline IDs do not exist");
+		}
+		await this.db.deleteFrom("_dineway_content_bylines").where("collection_slug", "=", collectionSlug).where("content_id", "=", contentId).execute();
+		for (let i = 0; i < bylines.length; i++) {
+			const item = bylines[i];
+			await this.db.insertInto("_dineway_content_bylines").values({
+				id: ulid(),
+				collection_slug: collectionSlug,
+				content_id: contentId,
+				byline_id: item.bylineId,
+				sort_order: i,
+				role_label: item.roleLabel ?? null,
+				created_at: (/* @__PURE__ */ new Date()).toISOString()
+			}).execute();
+		}
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET primary_byline_id = ${bylines[0]?.bylineId ?? null}
+			WHERE id = ${contentId}
+		`.execute(this.db);
+		return await this.getContentBylines(collectionSlug, contentId);
+	}
+};
+
+//#endregion
+export { SQL_BATCH_SIZE as n, chunks as r, BylineRepository as t };