@plumix/core 0.1.0

package/dist/rpc/procedures/entry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/entry/index.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBd,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC"}

package/dist/rpc/procedures/entry/index.js

@@ -0,0 +1,38 @@
+import { list as activityList } from "./activity.js";
+import { deletePermanentMany, restoreMany, trashMany } from "./bulk.js";
+import { createPreviewLink } from "./create-preview-link.js";
+import { create } from "./create.js";
+import { recentActivity, stats } from "./dashboard.js";
+import { deletePermanent } from "./delete-permanent.js";
+import { discardDraft } from "./discard-draft.js";
+import { duplicate } from "./duplicate.js";
+import { get } from "./get.js";
+import { list } from "./list.js";
+import { publish } from "./publish.js";
+import { refreshBlockLoader } from "./refresh-block-loader.js";
+import { restore } from "./restore.js";
+import { revisionsRouter } from "./revisions.js";
+import { trash } from "./trash.js";
+import { update } from "./update.js";
+export const entryRouter = {
+    list,
+    get,
+    create,
+    update,
+    trash,
+    restore,
+    deletePermanent,
+    trashMany,
+    restoreMany,
+    deletePermanentMany,
+    duplicate,
+    createPreviewLink,
+    refreshBlockLoader,
+    publish,
+    discardDraft,
+    stats,
+    recentActivity,
+    revisions: revisionsRouter,
+    activity: { list: activityList },
+};
+//# sourceMappingURL=index.js.map

package/dist/rpc/procedures/entry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/rpc/procedures/entry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI;IACJ,GAAG;IACH,MAAM;IACN,MAAM;IACN,KAAK;IACL,OAAO;IACP,eAAe;IACf,SAAS;IACT,WAAW;IACX,mBAAmB;IACnB,SAAS;IACT,iBAAiB;IACjB,kBAAkB;IAClB,OAAO;IACP,YAAY;IACZ,KAAK;IACL,cAAc;IACd,SAAS,EAAE,eAAe;IAC1B,QAAQ,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE;CACxB,CAAC"}

package/dist/rpc/procedures/entry/lifecycle.d.ts

@@ -0,0 +1,77 @@
+import type { AppContext, AuthenticatedAppContext } from "../../../context/app.js";
+import type { Entry, EntryStatus, NewEntry } from "../../../db/schema/entries.js";
+export declare function applyEntryBeforeSave(ctx: AppContext, type: string, entry: NewEntry): Promise<NewEntry>;
+export declare function fireEntryTransition(ctx: AppContext, entry: Entry, oldStatus: EntryStatus): Promise<void>;
+export declare function fireEntryPublished(ctx: AppContext, entry: Entry): Promise<void>;
+/**
+ * The `publishedAt` to stamp when an entry transitions to `published`, or
+ * `undefined` to leave the existing one. Stamps `now` when there's no publish
+ * time yet, or when promoting a scheduled entry whose time is still in the
+ * future (a future date would sort it to the top of feeds). Shared by the
+ * editor update and revision-restore publish paths so they can't diverge.
+ */
+export declare function publishedAtForTransition(existing: Date | null): Date | undefined;
+export declare function fireEntryUpdated(ctx: AppContext, entry: Entry, previous: Entry): Promise<void>;
+export declare function fireEntryTrashed(ctx: AppContext, entry: Entry): Promise<void>;
+export declare function fireEntryRestored(ctx: AppContext, entry: Entry): Promise<void>;
+export declare function fireEntryDeleted(ctx: AppContext, entry: Entry): Promise<void>;
+export declare function fireEntryAutosaveSaved(ctx: AppContext, autosave: Entry, live: Entry): Promise<void>;
+export declare function fireEntryAutosaveDiscarded(ctx: AppContext, live: Entry, authorId: number): Promise<void>;
+export declare function fireEntryRevisionRestored(ctx: AppContext, revision: Entry, destination: Entry, liveType: string): Promise<void>;
+export declare function entryCapability(type: string, action: string): string;
+/**
+ * Shared prelude for the trash-lifecycle procedures (trash / restore /
+ * deletePermanent): load-or-404, then gate on the `delete` capability
+ * plus author-or-`edit_any`. Deliberately distinct from the edit gate in
+ * `update.ts` (`(author AND edit_own) OR edit_any`, no `delete` cap) —
+ * don't unify them.
+ */
+interface DeletableGuards {
+    readonly notFound: (id: number) => never;
+    readonly forbidden: (capability: string) => never;
+}
+export declare function entryDeletableGuards(errors: {
+    NOT_FOUND: (opts: {
+        data: {
+            kind: string;
+            id: number;
+        };
+    }) => Error;
+    FORBIDDEN: (opts: {
+        data: {
+            capability: string;
+        };
+    }) => Error;
+}): DeletableGuards;
+export declare function loadDeletableEntry(ctx: AuthenticatedAppContext, id: number, guards: DeletableGuards): Promise<Entry>;
+/**
+ * Batched sibling of `loadDeletableEntry` for the bulk procedures: one
+ * `WHERE id IN (…)` read (no N+1), then per-row gating in memory.
+ * Fail-all — any missing id or any forbidden row throws, so a bulk op
+ * never half-applies across a mix of permitted and forbidden entries.
+ */
+export declare function loadDeletableEntries(ctx: AuthenticatedAppContext, ids: readonly number[], guards: DeletableGuards): Promise<Entry[]>;
+export declare function canReadEntry(ctx: AuthenticatedAppContext, entry: Entry): boolean;
+/**
+ * Load the parent referenced by a user-supplied parentId and verify it
+ * (a) exists, (b) shares the child's entry type, and (c) is visible to the
+ * caller per the same rules as `entry.get`. Returns null when any check
+ * fails — deliberately undistinguished so a caller can't probe for entry
+ * existence by reparenting. Callers should translate null into a 404.
+ */
+export declare function loadReadableParent(ctx: AuthenticatedAppContext, childType: string, parentId: number): Promise<Entry | null>;
+/**
+ * Walk the parent chain upward from `candidateParentId` and decide whether
+ * pointing `entryId` at it would create a cycle — i.e. whether entryId already
+ * appears in the chain above candidateParentId. Returns true on any cycle
+ * (including a pre-existing one walked into on the way up) or when the chain
+ * exceeds a sanity limit; callers should treat true as "reject".
+ *
+ * Necessary because update.ts alone can't catch cycles of depth > 1
+ * (A→B→A) from a self-id check; admin UI tree views will infinite-loop on
+ * any such cycle left in the DB.
+ */
+export declare function wouldCreateParentCycle(ctx: AuthenticatedAppContext, entryId: number, candidateParentId: number): Promise<boolean>;
+export declare function captureRevisionIfSupported(ctx: AuthenticatedAppContext, updated: Entry): Promise<void>;
+export {};
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/rpc/procedures/entry/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/entry/lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/rpc/procedures/entry/lifecycle.js

@@ -0,0 +1,223 @@
+import { eq, inArray } from "../../../db/index.js";
+import { entries } from "../../../db/schema/entries.js";
+import { pruneOldRevisions, snapshotAsRevision, } from "../../../revisions/repository.js";
+// Each lifecycle event fan-outs to two hook names: the type-scoped form
+// `entry:<type>:<event>` (targets one entry type) and the generic
+// `entry:<event>` (fires for every entry regardless of type). Plugins
+// subscribe to whichever granularity they need — no need to re-filter by
+// type inside a generic handler.
+export async function applyEntryBeforeSave(ctx, type, entry) {
+    const afterSpecific = await ctx.hooks.applyFilter(`entry:${type}:before_save`, entry);
+    return ctx.hooks.applyFilter("entry:before_save", afterSpecific);
+}
+export async function fireEntryTransition(ctx, entry, oldStatus) {
+    if (entry.status === oldStatus)
+        return;
+    await ctx.hooks.doAction(`entry:${entry.type}:transition`, entry, oldStatus);
+    await ctx.hooks.doAction("entry:transition", entry, oldStatus);
+}
+export async function fireEntryPublished(ctx, entry) {
+    await ctx.hooks.doAction(`entry:${entry.type}:published`, entry);
+    await ctx.hooks.doAction("entry:published", entry);
+}
+/**
+ * The `publishedAt` to stamp when an entry transitions to `published`, or
+ * `undefined` to leave the existing one. Stamps `now` when there's no publish
+ * time yet, or when promoting a scheduled entry whose time is still in the
+ * future (a future date would sort it to the top of feeds). Shared by the
+ * editor update and revision-restore publish paths so they can't diverge.
+ */
+export function publishedAtForTransition(existing) {
+    if (existing === null || existing.getTime() > Date.now())
+        return new Date();
+    return undefined;
+}
+export async function fireEntryUpdated(ctx, entry, previous) {
+    await ctx.hooks.doAction(`entry:${entry.type}:updated`, entry, previous);
+    await ctx.hooks.doAction("entry:updated", entry, previous);
+}
+export async function fireEntryTrashed(ctx, entry) {
+    await ctx.hooks.doAction(`entry:${entry.type}:trashed`, entry);
+    await ctx.hooks.doAction("entry:trashed", entry);
+}
+export async function fireEntryRestored(ctx, entry) {
+    await ctx.hooks.doAction(`entry:${entry.type}:restored`, entry);
+    await ctx.hooks.doAction("entry:restored", entry);
+}
+export async function fireEntryDeleted(ctx, entry) {
+    await ctx.hooks.doAction(`entry:${entry.type}:deleted`, entry);
+    await ctx.hooks.doAction("entry:deleted", entry);
+}
+// Type-specific event keys on the live entry's type — the autosave row
+// itself carries `type='autosave'`, but subscribers care about the
+// type of the entry being edited (e.g. `entry:post:autosave_saved`),
+// not the framework storage type.
+export async function fireEntryAutosaveSaved(ctx, autosave, live) {
+    await ctx.hooks.doAction(`entry:${live.type}:autosave_saved`, autosave, live);
+    await ctx.hooks.doAction("entry:autosave_saved", autosave, live);
+}
+export async function fireEntryAutosaveDiscarded(ctx, live, authorId) {
+    await ctx.hooks.doAction(`entry:${live.type}:autosave_discarded`, live, authorId);
+    await ctx.hooks.doAction("entry:autosave_discarded", live, authorId);
+}
+// `destination` is the row the snapshot landed on — autosave for
+// autosave-supporting types, live otherwise. `liveType` is always the
+// public entry type (the destination's type is `'autosave'` for
+// per-user pending edits) so subscribers fire under the same namespace
+// regardless of where the snapshot landed.
+export async function fireEntryRevisionRestored(ctx, revision, destination, liveType) {
+    await ctx.hooks.doAction(`entry:${liveType}:revision_restored`, revision, destination);
+    await ctx.hooks.doAction("entry:revision_restored", revision, destination);
+}
+export function entryCapability(type, action) {
+    return `entry:${type}:${action}`;
+}
+// The trash-lifecycle procedures (single + bulk) all translate a missing
+// row into NOT_FOUND and a failed cap into FORBIDDEN. `errors` is the
+// per-handler oRPC builder, so this is a thin shared adapter.
+export function entryDeletableGuards(errors) {
+    return {
+        notFound: (id) => {
+            throw errors.NOT_FOUND({ data: { kind: "entry", id } });
+        },
+        forbidden: (capability) => {
+            throw errors.FORBIDDEN({ data: { capability } });
+        },
+    };
+}
+// Pure (no query) gate: `delete` cap plus author-or-`edit_any`. Shared by
+// the single-row and batched loaders.
+function assertDeletable(ctx, entry, guards) {
+    const deleteCapability = entryCapability(entry.type, "delete");
+    if (!ctx.auth.can(deleteCapability))
+        guards.forbidden(deleteCapability);
+    if (entry.authorId !== ctx.user.id) {
+        const editAnyCapability = entryCapability(entry.type, "edit_any");
+        if (!ctx.auth.can(editAnyCapability))
+            guards.forbidden(editAnyCapability);
+    }
+}
+export async function loadDeletableEntry(ctx, id, guards) {
+    const existing = await ctx.db.query.entries.findFirst({
+        where: eq(entries.id, id),
+    });
+    if (!existing)
+        guards.notFound(id);
+    assertDeletable(ctx, existing, guards);
+    return existing;
+}
+/**
+ * Batched sibling of `loadDeletableEntry` for the bulk procedures: one
+ * `WHERE id IN (…)` read (no N+1), then per-row gating in memory.
+ * Fail-all — any missing id or any forbidden row throws, so a bulk op
+ * never half-applies across a mix of permitted and forbidden entries.
+ */
+export async function loadDeletableEntries(ctx, ids, guards) {
+    // Dedupe so a repeated id can't double-fire lifecycle hooks or inflate
+    // the result count — bulk ops act on each entry once.
+    const uniqueIds = [...new Set(ids)];
+    const rows = await ctx.db.query.entries.findMany({
+        where: inArray(entries.id, uniqueIds),
+    });
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    const ordered = [];
+    for (const id of uniqueIds) {
+        const row = byId.get(id);
+        if (!row)
+            guards.notFound(id);
+        assertDeletable(ctx, row, guards);
+        ordered.push(row);
+    }
+    return ordered;
+}
+// Mirrors the readability rules in `entry.get`: any type-level `read` cap,
+// and for non-published entries also requires `edit_any` or (author +
+// `edit_own`). `entry.get` inlines its own variant that also issues an
+// errors.NOT_FOUND directly; `entry.duplicate` reuses this to gate the
+// source it copies (a create cap alone would leak unreadable drafts).
+export function canReadEntry(ctx, entry) {
+    if (!ctx.auth.can(entryCapability(entry.type, "read")))
+        return false;
+    if (entry.status === "published")
+        return true;
+    if (ctx.auth.can(entryCapability(entry.type, "edit_any")))
+        return true;
+    return (entry.authorId === ctx.user.id &&
+        ctx.auth.can(entryCapability(entry.type, "edit_own")));
+}
+/**
+ * Load the parent referenced by a user-supplied parentId and verify it
+ * (a) exists, (b) shares the child's entry type, and (c) is visible to the
+ * caller per the same rules as `entry.get`. Returns null when any check
+ * fails — deliberately undistinguished so a caller can't probe for entry
+ * existence by reparenting. Callers should translate null into a 404.
+ */
+export async function loadReadableParent(ctx, childType, parentId) {
+    const parent = await ctx.db.query.entries.findFirst({
+        where: eq(entries.id, parentId),
+    });
+    if (!parent)
+        return null;
+    if (parent.type !== childType)
+        return null;
+    if (!canReadEntry(ctx, parent))
+        return null;
+    return parent;
+}
+/**
+ * Walk the parent chain upward from `candidateParentId` and decide whether
+ * pointing `entryId` at it would create a cycle — i.e. whether entryId already
+ * appears in the chain above candidateParentId. Returns true on any cycle
+ * (including a pre-existing one walked into on the way up) or when the chain
+ * exceeds a sanity limit; callers should treat true as "reject".
+ *
+ * Necessary because update.ts alone can't catch cycles of depth > 1
+ * (A→B→A) from a self-id check; admin UI tree views will infinite-loop on
+ * any such cycle left in the DB.
+ */
+export async function wouldCreateParentCycle(ctx, entryId, candidateParentId) {
+    const MAX_DEPTH = 64;
+    const visited = new Set();
+    let cursor = candidateParentId;
+    while (cursor !== null) {
+        if (cursor === entryId)
+            return true;
+        if (visited.has(cursor))
+            return true;
+        if (visited.size >= MAX_DEPTH)
+            return true;
+        visited.add(cursor);
+        const next = await ctx.db.query.entries.findFirst({
+            where: eq(entries.id, cursor),
+        });
+        cursor = next?.parentId ?? null;
+    }
+    return false;
+}
+// No-op when the type doesn't opt into `supports: ['revisions']`.
+// Fires `entry:<type>:revision_created` + the generic variant once
+// the snapshot lands; `revision_pruned` only fires when the cap
+// pushed rows past `maxRevisions`.
+export async function captureRevisionIfSupported(ctx, updated) {
+    const typeEntry = ctx.plugins.entryTypes.get(updated.type);
+    if (!typeEntry?.supports?.includes("revisions"))
+        return;
+    const cap = typeEntry.versioning?.maxRevisions ?? 25;
+    const revision = await snapshotAsRevision(ctx.db, {
+        entry: updated,
+        authorId: ctx.user.id,
+    });
+    // Prune BEFORE the created hook fires so subscribers see the
+    // post-prune list rather than a transient N+1 window.
+    const pruned = await pruneOldRevisions(ctx.db, {
+        entryId: updated.id,
+        maxRevisions: cap,
+    });
+    await ctx.hooks.doAction(`entry:${updated.type}:revision_created`, revision, updated);
+    await ctx.hooks.doAction("entry:revision_created", revision, updated);
+    if (pruned > 0) {
+        await ctx.hooks.doAction(`entry:${updated.type}:revision_pruned`, updated, pruned);
+        await ctx.hooks.doAction("entry:revision_pruned", updated, pruned);
+    }
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/rpc/procedures/entry/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../../../src/rpc/procedures/entry/lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/rpc/procedures/entry/list.d.ts

@@ -0,0 +1,114 @@
+export declare const list: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../index.js").AppContext, import("../../../index.js").AuthenticatedAppContext<typeof import("../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+    readonly type: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly status: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").OptionalSchema<import("valibot").EnumSchema<{
+        readonly draft: "draft";
+        readonly published: "published";
+        readonly scheduled: "scheduled";
+        readonly trash: "trash";
+    }, undefined>, undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").OptionalSchema<import("valibot").EnumSchema<{
+        readonly draft: "draft";
+        readonly published: "published";
+        readonly scheduled: "scheduled";
+        readonly trash: "trash";
+    }, undefined>, undefined>, undefined>, import("valibot").MinLengthAction<(import("valibot").EnumValues<{
+        readonly draft: "draft";
+        readonly published: "published";
+        readonly scheduled: "scheduled";
+        readonly trash: "trash";
+    }> | undefined)[], 1, undefined>]>], undefined>, undefined>;
+    readonly authorId: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
+    readonly parentId: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>, undefined>;
+    readonly search: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MaxLengthAction<string, 200, undefined>]>, undefined>;
+    readonly termTaxonomies: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 100, undefined>, import("valibot").RegexAction<string, "termTaxonomy must be kebab/snake ASCII">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>, undefined>, import("valibot").MaxLengthAction<string[], 50, undefined>]>, undefined>, undefined>;
+    readonly orderBy: import("valibot").OptionalSchema<import("valibot").PicklistSchema<readonly ["updated_at", "published_at", "title", "sort_order"], undefined>, "updated_at">;
+    readonly order: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["asc", "desc"], undefined>, "desc">;
+    readonly limit: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, 100, undefined>]>, 20>;
+    readonly offset: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, 0>;
+}, undefined>, import("@orpc/server").Schema<readonly {
+    id: number;
+    meta: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    type: string;
+    parentId: number | null;
+    title: string;
+    slug: string;
+    content: import("../../../index.js").EntryContent | null;
+    excerpt: string | null;
+    status: "draft" | "published" | "scheduled" | "trash";
+    authorId: number;
+    sortOrder: number;
+    publishedAt: Date | null;
+}[], readonly {
+    id: number;
+    meta: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    type: string;
+    parentId: number | null;
+    title: string;
+    slug: string;
+    content: import("../../../index.js").EntryContent | null;
+    excerpt: string | null;
+    status: "draft" | "published" | "scheduled" | "trash";
+    authorId: number;
+    sortOrder: number;
+    publishedAt: Date | null;
+}[]>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+    readonly UNAUTHORIZED: {
+        readonly message: "Authentication required";
+    };
+    readonly BAD_REQUEST: {
+        readonly message: "Invalid input";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly FORBIDDEN: {
+        readonly message: "Permission denied";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly capability: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly NOT_FOUND: {
+        readonly message: "Resource not found";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+        }, undefined>;
+    };
+    readonly CONFLICT: {
+        readonly message: "Resource conflict";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+            readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly message: "Payload too large";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly limit: import("valibot").NumberSchema<undefined>;
+            readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly message: "Unsupported media type";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly mime: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly INVALID_BLOCK_CONTENT: {
+        readonly message: "Block content failed registry validation";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+}>, Record<never, never>>;
+//# sourceMappingURL=list.d.ts.map

package/dist/rpc/procedures/entry/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/entry/list.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAcb,CAAC"}

package/dist/rpc/procedures/entry/list.js

@@ -0,0 +1,19 @@
+import { listEntries } from "../../../entries/read-service.js";
+import { authenticated } from "../../authenticated.js";
+import { base } from "../../base.js";
+import { toRpcEntryReadError } from "./read-errors.js";
+import { entryListInputSchema } from "./schemas.js";
+export const list = base
+    .use(authenticated)
+    .input(entryListInputSchema)
+    .handler(async ({ input, context, errors }) => {
+    const filtered = await context.hooks.applyFilter("rpc:entry.list:input", input);
+    try {
+        const rows = await listEntries(context, filtered);
+        return await context.hooks.applyFilter("rpc:entry.list:output", rows);
+    }
+    catch (error) {
+        throw toRpcEntryReadError(error, errors);
+    }
+});
+//# sourceMappingURL=list.js.map

package/dist/rpc/procedures/entry/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../../src/rpc/procedures/entry/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,CAAC,MAAM,IAAI,GAAG,IAAI;KACrB,GAAG,CAAC,aAAa,CAAC;KAClB,KAAK,CAAC,oBAAoB,CAAC;KAC3B,OAAO,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE;IAC5C,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,WAAW,CAC9C,sBAAsB,EACtB,KAAK,CACN,CAAC;IACF,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QAClD,OAAO,MAAM,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,uBAAuB,EAAE,IAAI,CAAC,CAAC;IACxE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/rpc/procedures/entry/lookup.d.ts

@@ -0,0 +1,4 @@
+import type { EntryFieldScope } from "../../../plugin/fields/entry.js";
+import type { LookupAdapter } from "../../../plugin/lookup.js";
+export declare const entryLookupAdapter: LookupAdapter<EntryFieldScope>;
+//# sourceMappingURL=lookup.d.ts.map

package/dist/rpc/procedures/entry/lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/entry/lookup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,2BAA2B,CAAC;AA2B7E,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,eAAe,CA2C7D,CAAC"}