@byline/db-mysql 4.8.0

package/dist/modules/storage/storage-insert.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { type FlattenedFieldValue } from '@byline/core';
+import type { booleanStore, datetimeStore, fileStore, jsonStore, metaStore, numericStore, relationStore, textStore } from '../../database/schema/index.js';
+type FieldInsertBuckets = {
+    text: (typeof textStore.$inferInsert)[];
+    numeric: (typeof numericStore.$inferInsert)[];
+    boolean: (typeof booleanStore.$inferInsert)[];
+    datetime: (typeof datetimeStore.$inferInsert)[];
+    file: (typeof fileStore.$inferInsert)[];
+    relation: (typeof relationStore.$inferInsert)[];
+    json: (typeof jsonStore.$inferInsert)[];
+    meta: (typeof metaStore.$inferInsert)[];
+};
+export declare const prepareFieldInsertBuckets: (flattenedFields: FlattenedFieldValue[], document_version_id: string, collection_id: string) => FieldInsertBuckets;
+export {};

package/dist/modules/storage/storage-insert.js

@@ -0,0 +1,152 @@
+/**
+ * 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 { ERR_DATABASE, getLogger } from '@byline/core';
+import { v7 as uuidv7 } from 'uuid';
+export const prepareFieldInsertBuckets = (flattenedFields, document_version_id, collection_id) => {
+    const buckets = {
+        text: [],
+        numeric: [],
+        boolean: [],
+        datetime: [],
+        file: [],
+        relation: [],
+        json: [],
+        meta: [],
+    };
+    for (const field of flattenedFields) {
+        const { field_type, field_path, locale } = field;
+        if (field_type === 'meta') {
+            buckets.meta.push({
+                id: uuidv7(),
+                document_version_id,
+                collection_id,
+                type: field.type,
+                path: field_path.join('.'),
+                item_id: field.item_id,
+            });
+            continue;
+        }
+        const base = {
+            id: uuidv7(),
+            document_version_id,
+            collection_id,
+            field_path: field_path.join('.'),
+            field_name: field_path[field_path.length - 1] ?? '',
+            locale,
+            parent_path: field_path.length > 1 ? field_path.slice(0, -1).join('.') : undefined,
+        };
+        switch (field_type) {
+            case 'text':
+                buckets.text.push({ ...base, value: field.value });
+                continue;
+            case 'numeric':
+                buckets.numeric.push({
+                    ...base,
+                    number_type: field.number_type,
+                    value_float: field.value_float,
+                    value_integer: field.value_integer,
+                    value_decimal: field.value_decimal,
+                });
+                continue;
+            case 'boolean':
+                buckets.boolean.push({
+                    ...base,
+                    value: field.value,
+                });
+                continue;
+            case 'datetime':
+                buckets.datetime.push({
+                    ...base,
+                    date_type: field.date_type,
+                    // Real dialect divergence from pg, found via typecheck rather than
+                    // assumed: `drizzle-orm/pg-core`'s `date()` defaults to *string*
+                    // mode (`PgDateStringBuilder`) unless `{ mode: 'date' }` is passed;
+                    // `drizzle-orm/mysql-core`'s `date()` defaults the other way — to
+                    // *`Date`* mode (`MySqlDateBuilder`) unless `{ mode: 'string' }` is
+                    // passed. The schema's `value_date: date('value_date')`
+                    // (`src/database/schema/index.ts`, unchanged from Task 8/PR 1) is
+                    // therefore `Date`-typed on insert here, the mirror image of pg's
+                    // `toDateOnlyString` — so this coerces to `Date` instead of a
+                    // 'YYYY-MM-DD' string. `mapToDriverValue` is identity (unverified
+                    // by an override in the mysql-core source), so mysql2 receives the
+                    // `Date` object directly and formats it per the pool's `timezone:
+                    // 'Z'` option.
+                    value_date: toDate(field.value_date),
+                    value_time: field.value_time,
+                    // `value_timestamp_tz` arrives as a `Date` from form widgets but
+                    // as a string from `getAllFieldValues` — the UNION ALL declares
+                    // the column as MySQL `DATETIME(6)` (no TZ; UTC by connection-level
+                    // convention, see `src/index.ts`'s `timezone: 'Z'` pool option),
+                    // and mysql2 maps a `datetime` column to a string on read.
+                    // Drizzle's own `mapToDriverValue` for the (default, non-'string')
+                    // `datetime()` builder calls `.toISOString()` unguarded on insert
+                    // — confirmed against the drizzle-orm/mysql-core source — so we
+                    // coerce here, exactly like pg's `toDate`.
+                    value_timestamp_tz: toDate(field.value_timestamp_tz),
+                });
+                continue;
+            case 'file':
+                buckets.file.push({
+                    ...base,
+                    file_id: field.file_id,
+                    filename: field.filename,
+                    original_filename: field.original_filename,
+                    mime_type: field.mime_type,
+                    file_size: field.file_size,
+                    storage_provider: field.storage_provider,
+                    storage_path: field.storage_path,
+                    storage_url: field.storage_url,
+                    file_hash: field.file_hash,
+                    image_width: field.image_width,
+                    image_height: field.image_height,
+                    image_format: field.image_format,
+                    processing_status: field.processing_status || 'pending', // TODO: Is 'pending' the appropriate default status?
+                    thumbnail_generated: field.thumbnail_generated || false,
+                    variants: field.variants,
+                });
+                continue;
+            case 'relation':
+                buckets.relation.push({
+                    ...base,
+                    target_document_id: field.target_document_id,
+                    target_collection_id: field.target_collection_id,
+                    relationship_type: field.relationship_type || 'reference', // TODO: Is this the appropriate place to set this?
+                    cascade_delete: field.cascade_delete || false, // TODO: Same question?
+                });
+                continue;
+            case 'json':
+                buckets.json.push({
+                    ...base,
+                    value: field.value,
+                });
+                continue;
+            default:
+                throw ERR_DATABASE({
+                    message: `unexpected field type: ${field_type}`,
+                    details: { fieldType: field_type },
+                }).log(getLogger());
+        }
+    }
+    return buckets;
+};
+/**
+ * Coerce a date/timestamp field value to a `Date` instance — both the
+ * MySQL `date` and (default-mode) `datetime` column builders require one on
+ * insert, per the dialect-divergence notes above. Accepts:
+ *   - `Date`   → passed through
+ *   - string   → parsed via `new Date(...)` (ISO, MySQL `date`, or MySQL
+ *     `datetime` shape — all parse correctly through the `Date` constructor)
+ *   - null / undefined → undefined (no insert)
+ */
+function toDate(value) {
+    if (value == null)
+        return undefined;
+    if (value instanceof Date)
+        return value;
+    return new Date(value);
+}