@byline/db-mysql 4.8.0

package/dist/modules/storage/tests/storage-status-and-lifecycle.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/modules/storage/tests/storage-status-and-lifecycle.test.js

@@ -0,0 +1,268 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { setupTestDB, teardownTestDB } from '../../../lib/test-helper.js';
+const timestamp = Date.now();
+function first(rows) {
+    const row = rows[0];
+    if (row == null)
+        throw new Error('expected at least one row, got none');
+    return row;
+}
+async function queryRows(pool, sql, params) {
+    const [rows] = await pool.query(sql, params);
+    return rows;
+}
+async function queryOne(pool, sql, params) {
+    return first(await queryRows(pool, sql, params));
+}
+const PostsCollectionConfig = {
+    path: `lifecycle-test-posts-${timestamp}`,
+    labels: { singular: 'Post', plural: 'Posts' },
+    fields: [
+        { name: 'title', type: 'text', localized: true },
+        {
+            name: 'links',
+            type: 'array',
+            fields: [{ name: 'label', type: 'text' }],
+        },
+    ],
+};
+describe('DocumentCommands status/archive/soft-delete/order-key/delete-locale (mysql, live database)', () => {
+    let testDb;
+    let rawPool;
+    let collectionId;
+    beforeAll(async () => {
+        testDb = setupTestDB([PostsCollectionConfig]);
+        rawPool = testDb.pool;
+        const created = first(await testDb.commandBuilders.collections.create(PostsCollectionConfig.path, PostsCollectionConfig));
+        collectionId = created.id;
+    });
+    afterAll(async () => {
+        await testDb.commandBuilders.collections.delete(collectionId);
+        await teardownTestDB();
+    });
+    describe('setDocumentStatus', () => {
+        it('mutates the version row in place — no new version minted', async () => {
+            const created = await testDb.commandBuilders.documents.createDocumentVersion({
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'create',
+                documentData: { title: 'Status Doc', links: [] },
+                locale: 'all',
+                status: 'draft',
+            });
+            const versionId = created.document.id;
+            const documentId = created.document.document_id;
+            await testDb.commandBuilders.documents.setDocumentStatus({
+                document_version_id: versionId,
+                status: 'published',
+            });
+            const versionRow = await queryOne(rawPool, 'SELECT status FROM byline_document_versions WHERE id = ?', [versionId]);
+            expect(versionRow.status).toBe('published');
+            const allVersions = await queryRows(rawPool, 'SELECT id FROM byline_document_versions WHERE document_id = ?', [documentId]);
+            expect(allVersions.length).toBe(1); // still one version — status is metadata, not content
+        });
+    });
+    describe('archivePublishedVersions', () => {
+        it('archives every published version of a document except an excluded one', async () => {
+            const v1 = await testDb.commandBuilders.documents.createDocumentVersion({
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'create',
+                documentData: { title: 'Archive Doc v1', links: [] },
+                locale: 'all',
+                status: 'published',
+            });
+            const documentId = v1.document.document_id;
+            const v2 = await testDb.commandBuilders.documents.createDocumentVersion({
+                documentId,
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'update',
+                documentData: { title: 'Archive Doc v2', links: [] },
+                locale: 'all',
+                status: 'published',
+            });
+            const updated = await testDb.commandBuilders.documents.archivePublishedVersions({
+                document_id: documentId,
+                currentStatus: 'published',
+                excludeVersionId: v2.document.id,
+            });
+            expect(updated).toBe(1);
+            const v1Row = await queryOne(rawPool, 'SELECT status FROM byline_document_versions WHERE id = ?', [v1.document.id]);
+            expect(v1Row.status).toBe('archived');
+            const v2Row = await queryOne(rawPool, 'SELECT status FROM byline_document_versions WHERE id = ?', [v2.document.id]);
+            expect(v2Row.status).toBe('published'); // excluded — untouched
+            const versionCount = await queryRows(rawPool, 'SELECT id FROM byline_document_versions WHERE document_id = ?', [documentId]);
+            expect(versionCount.length).toBe(2); // no new version minted by archiving
+        });
+        it('returns 0 when no version matches the target status', async () => {
+            const created = await testDb.commandBuilders.documents.createDocumentVersion({
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'create',
+                documentData: { title: 'Never Published', links: [] },
+                locale: 'all',
+                status: 'draft',
+            });
+            const updated = await testDb.commandBuilders.documents.archivePublishedVersions({
+                document_id: created.document.document_id,
+            });
+            expect(updated).toBe(0);
+        });
+    });
+    describe('softDeleteDocument', () => {
+        it('marks every version of a document as deleted', async () => {
+            const v1 = await testDb.commandBuilders.documents.createDocumentVersion({
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'create',
+                documentData: { title: 'Delete Doc v1', links: [] },
+                locale: 'all',
+                status: 'draft',
+            });
+            const documentId = v1.document.document_id;
+            await testDb.commandBuilders.documents.createDocumentVersion({
+                documentId,
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'update',
+                documentData: { title: 'Delete Doc v2', links: [] },
+                locale: 'all',
+                status: 'draft',
+            });
+            const affected = await testDb.commandBuilders.documents.softDeleteDocument({
+                document_id: documentId,
+            });
+            expect(affected).toBe(2);
+            const rows = await queryRows(rawPool, 'SELECT is_deleted FROM byline_document_versions WHERE document_id = ?', [documentId]);
+            expect(rows.length).toBe(2); // rows preserved, only tombstoned
+            expect(rows.every((r) => r.is_deleted === 1)).toBe(true);
+        });
+        it('returns 0 for a document with no version rows (defensive guard)', async () => {
+            const affected = await testDb.commandBuilders.documents.softDeleteDocument({
+                document_id: '00000000-0000-7000-8000-000000000000',
+            });
+            expect(affected).toBe(0);
+        });
+    });
+    describe('setOrderKey', () => {
+        it('writes order_key on byline_documents without touching the version stream', async () => {
+            const created = await testDb.commandBuilders.documents.createDocumentVersion({
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'create',
+                documentData: { title: 'Order Key Doc', links: [] },
+                locale: 'all',
+                status: 'draft',
+            });
+            const documentId = created.document.document_id;
+            await testDb.commandBuilders.documents.setOrderKey({
+                document_id: documentId,
+                order_key: 'a0',
+            });
+            const docRow = await queryOne(rawPool, 'SELECT order_key FROM byline_documents WHERE id = ?', [documentId]);
+            expect(docRow.order_key).toBe('a0');
+            const versionCount = await queryRows(rawPool, 'SELECT id FROM byline_document_versions WHERE document_id = ?', [documentId]);
+            expect(versionCount.length).toBe(1); // no new version
+        });
+    });
+    describe('deleteDocumentLocale', () => {
+        it('writes a new version carrying forward every locale except the deleted one, plus meta identities', async () => {
+            const v1 = await testDb.commandBuilders.documents.createDocumentVersion({
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'create',
+                documentData: {
+                    title: { en: 'Hello', es: 'Hola', fr: 'Bonjour' },
+                    links: [{ label: 'one' }],
+                },
+                locale: 'all',
+                status: 'draft',
+            });
+            const documentId = v1.document.document_id;
+            const firstVersionId = v1.document.id;
+            const result = await testDb.commandBuilders.documents.deleteDocumentLocale({
+                documentId,
+                locale: 'es',
+                status: 'draft',
+            });
+            expect(result).not.toBeNull();
+            expect(result?.previousVersionId).toBe(firstVersionId);
+            const newVersionId = result?.newVersionId;
+            expect(newVersionId).not.toBe(firstVersionId);
+            // A genuinely new, distinct version row.
+            const versionRows = await queryRows(rawPool, 'SELECT id, event_type, status, change_summary FROM byline_document_versions WHERE document_id = ? ORDER BY id', [documentId]);
+            expect(versionRows.length).toBe(2);
+            const newVersionRow = versionRows.find((r) => r.id === newVersionId);
+            expect(newVersionRow.event_type).toBe('delete_locale');
+            expect(newVersionRow.status).toBe('draft');
+            expect(newVersionRow.change_summary).toBe('deleted content locale es');
+            // 'en' and 'fr' carried forward; 'es' dropped.
+            const titleRows = await queryRows(rawPool, "SELECT locale, value FROM byline_store_text WHERE document_version_id = ? AND field_name = 'title' ORDER BY locale", [newVersionId]);
+            expect(titleRows.map((r) => [r.locale, r.value])).toEqual([
+                ['en', 'Hello'],
+                ['fr', 'Bonjour'],
+            ]);
+            // The prior version is untouched (immutability) — still has all three.
+            const prevTitleRows = await queryRows(rawPool, "SELECT locale FROM byline_store_text WHERE document_version_id = ? AND field_name = 'title' ORDER BY locale", [firstVersionId]);
+            expect(prevTitleRows.map((r) => r.locale)).toEqual(['en', 'es', 'fr']);
+            // Meta identity rows (the array item's stable _id) carried forward too.
+            const newMetaRows = await queryRows(rawPool, 'SELECT type, path, item_id FROM byline_store_meta WHERE document_version_id = ?', [newVersionId]);
+            const prevMetaRows = await queryRows(rawPool, 'SELECT type, path, item_id FROM byline_store_meta WHERE document_version_id = ?', [firstVersionId]);
+            expect(newMetaRows.length).toBe(prevMetaRows.length);
+            expect(newMetaRows.length).toBeGreaterThan(0);
+            expect(new Set(newMetaRows.map((r) => r.item_id))).toEqual(new Set(prevMetaRows.map((r) => r.item_id)));
+            // The completeness ledger no longer advertises 'es'.
+            const ledgerRows = await queryRows(rawPool, 'SELECT locale FROM byline_document_version_locales WHERE document_version_id = ? ORDER BY locale', [newVersionId]);
+            expect(ledgerRows.map((r) => r.locale)).toEqual(['en', 'fr']);
+        });
+        it('returns null when the document has no current (non-deleted) version', async () => {
+            const result = await testDb.commandBuilders.documents.deleteDocumentLocale({
+                documentId: '00000000-0000-7000-8000-000000000000',
+                locale: 'es',
+            });
+            expect(result).toBeNull();
+        });
+        it('returns null when every version of the document has been soft-deleted', async () => {
+            // Distinct from the "wholly absent document" case above — this
+            // document genuinely exists and has version rows, but all of them
+            // carry `is_deleted = true`, so the `AND is_deleted = false` filter
+            // in `deleteDocumentLocale`'s current-version lookup excludes every
+            // one of them, the same guard it hits for an absent document.
+            const created = await testDb.commandBuilders.documents.createDocumentVersion({
+                collectionId,
+                collectionVersion: 1,
+                collectionConfig: PostsCollectionConfig,
+                action: 'create',
+                documentData: { title: { en: 'Soft-Deleted', es: 'Borrado', fr: 'Supprimé' } },
+                locale: 'all',
+                status: 'draft',
+            });
+            const documentId = created.document.document_id;
+            const affected = await testDb.commandBuilders.documents.softDeleteDocument({
+                document_id: documentId,
+            });
+            expect(affected).toBe(1);
+            const result = await testDb.commandBuilders.documents.deleteDocumentLocale({
+                documentId,
+                locale: 'es',
+            });
+            expect(result).toBeNull();
+        });
+    });
+});

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@byline/db-mysql",
+  "private": false,
+  "license": "MPL-2.0",
+  "version": "4.8.0",
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "description": "Byline CMS db mysql package",
+  "keywords": [
+    "cms",
+    "headless cms",
+    "content management"
+  ],
+  "homepage": "https://github.com/Byline-CMS/bylinecms.dev",
+  "bugs": {
+    "url": "https://github.com/Byline-CMS/bylinecms.dev/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Byline-CMS/bylinecms.dev.git",
+    "directory": "packages/db-mysql"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "index": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./admin": {
+      "types": "./dist/modules/admin/index.d.ts",
+      "import": "./dist/modules/admin/index.js",
+      "require": "./dist/modules/admin/index.js"
+    },
+    "./schema": {
+      "types": "./dist/database/schema/index.d.ts",
+      "import": "./dist/database/schema/index.js",
+      "require": "./dist/database/schema/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "drizzle-orm": "^0.45.2",
+    "mysql2": "^3.23.1",
+    "uuid": "^14.0.1",
+    "@byline/admin": "4.8.0",
+    "@byline/core": "4.8.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.4",
+    "@types/node": "^26.1.1",
+    "chokidar": "^5.0.0",
+    "chokidar-cli": "^3.0.0",
+    "dotenv": "^17.4.2",
+    "drizzle-kit": "^0.31.10",
+    "npm-run-all": "^4.1.5",
+    "tsc-alias": "^1.9.1",
+    "tsx": "^4.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "@byline/auth": "4.8.0",
+    "@byline/db-conformance": "0.0.2",
+    "@byline/client": "4.8.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "dev": "chokidar 'src/**/*' -c 'npm-run-all build'",
+    "build": "tsc -p tsconfig.json && tsc-alias",
+    "clean": "node scripts/clean.js node_modules dist build .turbo",
+    "lint": "biome check --write --unsafe --diagnostic-level=error",
+    "db:init": "cd src/database && ./db_init.sh",
+    "drizzle:generate": "tsc -p tsconfig.json && drizzle-kit generate --config=drizzle.config.ts",
+    "drizzle:migrate": "drizzle-kit migrate --config=drizzle.config.ts",
+    "drizzle:push": "tsc -p tsconfig.json && drizzle-kit push --config=drizzle.config.ts",
+    "drizzle:drop": "drizzle-kit drop --config=drizzle.config.ts",
+    "test": "vitest run --mode=node",
+    "test:integration": "LOG_LEVEL=off vitest run --mode=integration",
+    "test:watch": "LOG_LEVEL=off vitest --mode=integration",
+    "typecheck": "tsc --noEmit"
+  }
+}