@qkix/strapi-plugin-rewind 0.1.3 → 0.2.0

package/dist/server/src/config/index.d.ts

@@ -31,7 +31,7 @@ declare const _default: {
          * On by default, because a version table that only grows is a problem the
          * plugin would be creating rather than solving. The defaults are gentle:
          * a full week of every save, then a version a day for a month, then one a
-         * week — and anchors (publish, unpublish, discard, restore) and pinned
+         * week - and anchors (publish, unpublish, discard, restore) and pinned
          * versions are never removed at all, whatever their age.
          *
          * Set `enabled: false` to keep everything forever and manage it yourself.

package/dist/server/src/content-types/index.d.ts

@@ -2,8 +2,8 @@
  * The versions table.
  *
  * `relatedDocumentId`, not `documentId`: Strapi injects a `documentId` into
- * every content type and rejects the name outright — "The attribute
- * "documentId" is reserved and cannot be used in a model" — at boot, before
+ * every content type and rejects the name outright - "The attribute
+ * "documentId" is reserved and cannot be used in a model" - at boot, before
  * anything else runs. Strapi's own history model calls it `relatedDocumentId`
  * for the same reason.
  *

package/dist/server/src/controllers/index.d.ts

@@ -6,6 +6,7 @@ declare const _default: {
         findOne(ctx: any): Promise<any>;
         diff(ctx: any): Promise<any>;
         preview(ctx: any): Promise<any>;
+        pin(ctx: any): Promise<any>;
         restore(ctx: any): Promise<any>;
     };
 };

package/dist/server/src/controllers/version.d.ts

@@ -6,6 +6,12 @@ declare const version: ({ strapi }: {
     findOne(ctx: any): Promise<any>;
     diff(ctx: any): Promise<any>;
     preview(ctx: any): Promise<any>;
+    /**
+     * `pinned` is read from the body rather than inferred as a toggle, so that two
+     * editors with the panel open cannot flip the same version past each other:
+     * each request states the state it wants, and the last one wins visibly.
+     */
+    pin(ctx: any): Promise<any>;
     restore(ctx: any): Promise<any>;
 };
 export default version;

package/dist/server/src/index.d.ts

@@ -112,6 +112,7 @@ declare const _default: {
             findOne(ctx: any): Promise<any>;
             diff(ctx: any): Promise<any>;
             preview(ctx: any): Promise<any>;
+            pin(ctx: any): Promise<any>;
             restore(ctx: any): Promise<any>;
         };
     };
@@ -161,6 +162,14 @@ declare const _default: {
             acquire(name: string, ttlMs: number): Promise<boolean>;
             release(name: string): Promise<void>;
         };
+        pin: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            set(versionId: number, pinned: boolean): Promise<{
+                id: number;
+                pinned: boolean;
+            }>;
+        };
     };
 };
 export default _default;

package/dist/server/src/services/diff.d.ts

@@ -8,17 +8,17 @@ export interface FieldChange {
     type: string;
     /**
      * A custom field's uid, when the attribute is one. Custom fields all report
-     * their storage type — usually `json` — so this is the only thing specific
+     * their storage type - usually `json` - so this is the only thing specific
      * enough for the owning package to key a diff renderer on.
      */
     customField?: string;
     kind: ChangeKind;
-    /** Scalars only — the values themselves, for a plain before/after. */
+    /** Scalars only - the values themselves, for a plain before/after. */
     before?: unknown;
     after?: unknown;
-    /** Prose fields — a word-level diff of the readable text. */
+    /** Prose fields - a word-level diff of the readable text. */
     spans?: DiffSpan[];
-    /** Relations and media — what was linked and unlinked. */
+    /** Relations and media - what was linked and unlinked. */
     linked?: RelationRef[];
     unlinked?: RelationRef[];
 }
@@ -45,8 +45,8 @@ declare const diff: ({ strapi }: {
     /**
      * What changed between a version and the one before it.
      *
-     * Comparing against the previous version — rather than against the document
-     * as it stands — is what makes a history readable: each entry answers "what
+     * Comparing against the previous version - rather than against the document
+     * as it stands - is what makes a history readable: each entry answers "what
      * did this edit do?". The other question, "what would restoring this
      * change?", is what `restore.preview()` already answers.
      */

package/dist/server/src/services/index.d.ts

@@ -31,5 +31,13 @@ declare const _default: {
         acquire(name: string, ttlMs: number): Promise<boolean>;
         release(name: string): Promise<void>;
     };
+    pin: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        set(versionId: number, pinned: boolean): Promise<{
+            id: number;
+            pinned: boolean;
+        }>;
+    };
 };
 export default _default;

package/dist/server/src/services/lock.d.ts

@@ -8,7 +8,7 @@ import type { Core } from '@strapi/strapi';
  *
  * Best-effort is the honest description: read-then-write is not atomic, so two
  * instances starting within the same millisecond can both win. That is
- * acceptable for a nightly tidy-up and not for anything else — do not reuse
+ * acceptable for a nightly tidy-up and not for anything else - do not reuse
  * this for something that must happen exactly once.
  */
 declare const lock: ({ strapi }: {

package/dist/server/src/services/pin.d.ts

@@ -0,0 +1,19 @@
+import type { Core } from '@strapi/strapi';
+/**
+ * Pinning is the only write an editor makes to the history itself rather than
+ * to a document, so it is deliberately the smallest one available: a boolean on
+ * a row, no cascade, and no effect beyond prune skipping that row from then on
+ * (see `selectExpendable` in ../utils/thinning).
+ *
+ * It is kept out of the controller so that it can be exercised against a real
+ * database in the integration tests, which have no HTTP layer to call.
+ */
+declare const pin: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    set(versionId: number, pinned: boolean): Promise<{
+        id: number;
+        pinned: boolean;
+    }>;
+};
+export default pin;

package/dist/server/src/services/restore.d.ts

@@ -3,9 +3,9 @@ import type { RelationRef } from './serializer';
 export interface RestorePreview {
     /** Fields that will be written back. */
     fieldsToRestore: string[];
-    /** In the model but not in the version — left exactly as they are. */
+    /** In the model but not in the version - left exactly as they are. */
     fieldsKeptAsIs: string[];
-    /** In the version but no longer in the model — skipped. */
+    /** In the version but no longer in the model - skipped. */
     fieldsDropped: string[];
     /** Not localised, so restoring them changes every locale at once. */
     crossLocaleFields: string[];
@@ -26,14 +26,14 @@ declare const restore: ({ strapi }: {
      *
      * A separate call, and the UI shows it before asking for confirmation.
      * Restore without a preview of the consequences is a trap rather than a
-     * tool — `crossLocaleFields` in particular, where restoring the Polish
+     * tool - `crossLocaleFields` in particular, where restoring the Polish
      * version of a document quietly rewrites a field in every other language.
      */
     preview(versionId: number): Promise<RestorePreview>;
     /**
      * Writes the version back, to the draft only.
      *
-     * The document lands in "modified" and publishing stays a deliberate act —
+     * The document lands in "modified" and publishing stays a deliberate act -
      * restoring must never change what the public sees on its own.
      */
     apply(versionId: number, userId: number | null): Promise<{

package/dist/server/src/services/serializer.d.ts

@@ -3,8 +3,8 @@
  *
  * Written for this plugin rather than lifted from Strapi's own history module.
  * Where the shapes here resemble theirs it is because Strapi's populate API
- * dictates them — a relation can only be populated by naming its fields, a
- * dynamic zone only through `on` fragments — not because the code was copied.
+ * dictates them - a relation can only be populated by naming its fields, a
+ * dynamic zone only through `on` fragments - not because the code was copied.
  * Their implementation is MIT and was read while working out what the problem
  * actually is; two facts learned that way are worth stating outright, since
  * both cost a day if you meet them the hard way:
@@ -26,7 +26,7 @@ import type { Core } from '@strapi/strapi';
  * The timestamps and author columns change on every write, so a version that
  * keeps them can never be compared with another. `locale` and `localizations`
  * are injected by i18n and describe how the document is wired up rather than
- * what it says — restoring them would try to rewrite the translation graph.
+ * what it says - restoring them would try to rewrite the translation graph.
  */
 export declare const FIELDS_TO_IGNORE: string[];
 export interface RelationRef {

package/dist/server/src/services/snapshot.d.ts

@@ -9,7 +9,7 @@ declare const snapshot: ({ strapi }: {
      * Writes one version per affected locale, for each buffered intent.
      *
      * Called from the transaction's commit hook and never awaited by the write
-     * path — a failure here must not be able to reach the editor's save.
+     * path - a failure here must not be able to reach the editor's save.
      */
     captureAll(intents: SnapshotIntent[], userId: number | null): Promise<void>;
     capture(intent: SnapshotIntent, userId: number | null): Promise<void>;

package/dist/server/src/utils/backfillLabels.d.ts

@@ -3,7 +3,7 @@ import type { Core } from '@strapi/strapi';
  * Gives versions recorded before labels existed something to show.
  *
  * Without this, upgrading leaves a history where older entries are a badge and
- * a timestamp and newer ones have a title — the list stays half-unreadable for
+ * a timestamp and newer ones have a title - the list stays half-unreadable for
  * exactly as long as the old versions are worth keeping.
  *
  * Two details that matter:

package/dist/server/src/utils/captureContext.d.ts

@@ -11,7 +11,7 @@ export interface SnapshotIntent {
  * Intents buffered against the transaction they belong to.
  *
  * Keyed by the Knex transaction object because that is the only thing the
- * Content Manager's `update` and `publish` calls have in common — they are
+ * Content Manager's `update` and `publish` calls have in common - they are
  * sequential siblings, not nested, so nothing about the call stack relates
  * them. Strapi hands the same `trx` to every nested `db.transaction`, which
  * makes it a reliable key, and a WeakMap means a finished transaction takes its

package/dist/server/src/utils/persistTable.d.ts

@@ -3,8 +3,8 @@ import type { Core } from '@strapi/strapi';
  * Keeps the versions table alive when the plugin is not loaded.
  *
  * Strapi's schema sync drops any table it previously tracked that is no longer
- * in the user schema. Disable this plugin for a single boot — to debug, to test
- * an upgrade — and the history it exists to protect is gone without a prompt.
+ * in the user schema. Disable this plugin for a single boot - to debug, to test
+ * an upgrade - and the history it exists to protect is gone without a prompt.
  *
  * `persisted_tables` is the core-store key `@strapi/database` consults before
  * dropping (schema/diff.js). The EE `admin::persist-tables` service writes the

package/dist/server/src/utils/textDiff.d.ts

@@ -1,7 +1,7 @@
 /**
  * A word-level diff, and the text extraction that makes it useful.
  *
- * The alternative — reporting "content changed" — is true and worthless. The
+ * The alternative - reporting "content changed" - is true and worthless. The
  * field an editor cares most about is usually rich text stored as JSON, so the
  * readable part is pulled out and compared as prose. That is renderer-agnostic:
  * it walks the structure collecting anything that reads as text, without
@@ -29,7 +29,7 @@ export declare const diffWords: (before: string, after: string) => DiffSpan[];
  * Pulls the human-readable text out of an arbitrary value.
  *
  * Rich text, components and dynamic zones are all nested objects and arrays
- * whose shape this plugin deliberately does not model — a `text` key here, a
+ * whose shape this plugin deliberately does not model - a `text` key here, a
  * `children` array there. Collecting every string reached is imprecise but
  * stable across editors, and it is what turns "content changed" into a sentence
  * an editor recognises.

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@qkix/strapi-plugin-rewind",
-  "version": "0.1.3",
-  "description": "Document version history for Strapi v5 — snapshots on every save, with restore",
+  "version": "0.2.0",
+  "description": "Document version history for Strapi v5 - snapshots on every save, with restore",
   "strapi": {
     "kind": "plugin",
     "name": "rewind",
     "displayName": "Rewind",
-    "description": "Document version history for Strapi v5 — snapshots on every save, with restore"
+    "description": "Document version history for Strapi v5 - snapshots on every save, with restore"
   },
   "keywords": [
     "strapi",
@@ -55,8 +55,8 @@
     "styled-components": "^6.1.17",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@qkix/eslint-config": "0.0.0",
     "@qkix/strapi-test-harness": "0.0.0",
+    "@qkix/eslint-config": "0.0.0",
     "@qkix/tsconfig": "0.0.0"
   },
   "peerDependencies": {