dineway 0.1.49 → 0.2.0

package/dist/{types-GaCtZ1k9.d.mts → types-CDpH6MA4.d.mts}

@@ -289,6 +289,24 @@ interface ImportResult {
     error: string;
   }>;
   byCollection: Record<string, number>;
+  /** Number of taxonomy term assignments written during plugin import */
+  taxonomyAssignments?: number;
+  /** Source taxonomies skipped because no matching Dineway taxonomy def exists */
+  missingTaxonomies?: string[];
+  /** Custom taxonomy defs auto-created during plugin import */
+  taxonomiesCreated?: string[];
+  /** Navigation menu import summary */
+  menus?: {
+    created: number;
+    items: number;
+  };
+  /** Comment import summary */
+  comments?: {
+    imported: number;
+    skipped: number;
+  };
+  /** Site settings applied from the source */
+  siteSettings?: string[];
 }
 /**
  * An import source provides content from an external system.

package/dist/{types-DRIKLmJI.d.mts → types-C_ly5eTp.d.mts}

@@ -1,4 +1,4 @@
-import { c as CustomFieldValue } from "./types-CwawBUTa.mjs";
+import { c as CustomFieldValue } from "./types-DW_-sFyz.mjs";
 
 //#region src/database/repositories/types.d.ts
 interface CreateContentInput {
@@ -52,6 +52,14 @@ interface BylineSummary {
   avatarStorageKey?: string | null;
   /** Avatar media alt text from the same media join. */
   avatarAlt?: string | null;
+  /**
+   * Avatar media blurhash placeholder from the same media join. Null when
+   * the byline has no avatar, the avatar has no placeholder, or the byline
+   * was loaded through a plain finder that does not join media.
+   */
+  avatarBlurhash?: string | null;
+  /** Avatar media dominant color placeholder from the same media join. */
+  avatarDominantColor?: string | null;
   websiteUrl: string | null;
   userId: string | null;
   isGuest: boolean;
@@ -97,6 +105,13 @@ interface FindManyResult<T> {
   nextCursor?: string;
   total?: number;
 }
+/** Encode a cursor from order value + id */
+declare function encodeCursor(orderValue: string, id: string): string;
+/** Decode a cursor to order value + id. Returns null if invalid. */
+declare function decodeCursor(cursor: string): {
+  orderValue: string;
+  id: string;
+} | null;
 interface ContentItem {
   id: string;
   type: string;
@@ -128,4 +143,4 @@ declare class ScheduledNotDueError extends Error {
   constructor();
 }
 //#endregion
-export { ContentSeo as a, DinewayValidationError as c, ScheduledNotDueError as d, UpdateContentInput as f, ContentItem as i, FindManyOptions as l, ContentBylineCredit as n, ContentSeoInput as o, ContentDateField as r, CreateContentInput as s, BylineSummary as t, FindManyResult as u };
+export { ContentSeo as a, DinewayValidationError as c, ScheduledNotDueError as d, UpdateContentInput as f, ContentItem as i, FindManyOptions as l, encodeCursor as m, ContentBylineCredit as n, ContentSeoInput as o, decodeCursor as p, ContentDateField as r, CreateContentInput as s, BylineSummary as t, FindManyResult as u };

package/dist/types-DF7ZuGGk.d.mts

@@ -0,0 +1,118 @@
+//#region src/object-cache/types.d.ts
+/**
+ * Object cache types
+ *
+ * The object cache is an optional, distributed read-through cache that sits
+ * *beneath* the per-request cache (`requestCached`) and *above* the database.
+ * Query results (content entries, settings, menus, taxonomies) are stored in a
+ * fast key/value store (an in-process memory store on Node, or another
+ * compatible backend supplied by an extension package) so repeat reads across
+ * requests skip the database entirely.
+ *
+ * Backends only ever deal in strings — serialization (including `Date`
+ * preservation) is handled by the core read-through layer in `./codec.ts`, so
+ * every backend behaves identically.
+ */
+/**
+ * A pluggable object-cache backend.
+ *
+ * Implementations must be safe to call concurrently and should never throw on
+ * cache misses — `get` returns `null` for a miss. A backend that throws (e.g.
+ * a transient backend error) degrades gracefully: the read-through layer
+ * treats a thrown `get` as a miss and a thrown `set` as a no-op, so the
+ * database remains the source of truth.
+ */
+interface ObjectCacheBackend {
+  /** Return the stored string for `key`, or `null` on a miss. */
+  get(key: string): Promise<string | null>;
+  /**
+   * Store `value` under `key`.
+   *
+   * @param ttlSeconds Optional time-to-live in seconds. Backends that don't
+   *   support TTLs may ignore it, but shared backends should honor it so
+   *   orphaned, epoch-busted keys are eventually reclaimed.
+   */
+  set(key: string, value: string, ttlSeconds?: number): Promise<void>;
+  /** Remove `key`. Idempotent — deleting a missing key is not an error. */
+  delete(key: string): Promise<void>;
+}
+/**
+ * Serializable descriptor for an object-cache backend.
+ *
+ * Mirrors {@link import("../storage/types.js").StorageDescriptor}: `entrypoint`
+ * is a module specifier resolved at build time that exports a
+ * {@link CreateObjectCacheBackendFn} named `createObjectCache`; `config` is the
+ * plain, serializable runtime config passed to it.
+ */
+interface ObjectCacheDescriptor {
+  /** Module path exporting a `createObjectCache` function. */
+  entrypoint: string;
+  /** Serializable config passed to `createObjectCache` at runtime. */
+  config: ObjectCacheRuntimeConfig;
+}
+/**
+ * Runtime config shared by every backend, plus backend-specific keys.
+ *
+ * The read-through layer reads `defaultTtl`, `revalidate`, and `keyPrefix`;
+ * individual backends read their own keys (e.g. the memory backend reads
+ * `maxEntries`).
+ */
+interface ObjectCacheRuntimeConfig {
+  /**
+   * Default time-to-live for cached entries, in seconds.
+   *
+   * Invalidation works by epoch comparison, not key deletion: a stale value
+   * is detected on read (its stored epoch no longer matches) and overwritten
+   * in place under the same key. The TTL is just a backstop that reclaims
+   * keys that are never read again.
+   *
+   * @default 3600 (1 hour)
+   */
+  defaultTtl?: number;
+  /**
+   * How long (milliseconds) an isolate may reuse a cached namespace epoch
+   * before re-reading it from the backend.
+   *
+   * After a write bumps a namespace's epoch, an isolate keeps serving the
+   * previous epoch's keys until its cached epoch expires after this window.
+   * Shared backends may add their own propagation delay. Only anonymous
+   * visitors are affected — preview and edit requests bypass the cache.
+   *
+   * Set to `0` to re-read the epoch on every query (strongest freshness, more
+   * backend reads).
+   *
+   * @default 1000
+   */
+  revalidate?: number;
+  /**
+   * Prefix applied to every cache key. Lets multiple Dineway sites share one
+   * backend without colliding.
+   *
+   * @default "dineway"
+   */
+  keyPrefix?: string;
+  /**
+   * Maximum time (milliseconds) to wait for a single backend read before
+   * treating it as a cache miss and falling back to the database.
+   *
+   * Guards against a backend operation that stalls without resolving or
+   * rejecting, which would otherwise hang the request. A timed-out read
+   * degrades to a miss; the database remains the source of truth.
+   *
+   * Set to `0` to disable the timeout.
+   *
+   * @default 2000
+   */
+  timeout?: number;
+  /** Backend-specific keys. */
+  [key: string]: unknown;
+}
+/**
+ * Factory signature exported as `createObjectCache` from a backend entrypoint.
+ *
+ * Each backend accesses its own resources directly; the bundled memory backend
+ * uses an in-process map.
+ */
+type CreateObjectCacheBackendFn = (config: ObjectCacheRuntimeConfig) => ObjectCacheBackend;
+//#endregion
+export { ObjectCacheRuntimeConfig as i, ObjectCacheBackend as n, ObjectCacheDescriptor as r, CreateObjectCacheBackendFn as t };