@yunsoft/yuncms-core 0.1.0

package/src/storage/storage-registry.js

@@ -0,0 +1,39 @@
+function assertDriver(name, driver) {
+  for (const method of ['put', 'get', 'delete', 'stat', 'getSignedUrl']) {
+    if (typeof driver?.[method] !== 'function') {
+      throw new Error(`Storage driver ${name} must implement ${method}()`);
+    }
+  }
+  return driver;
+}
+
+export function createStorageRegistry(drivers = {}) {
+  const entries = Object.entries(drivers);
+  if (entries.length === 0) throw new Error('At least one storage driver is required');
+
+  const registry = new Map();
+  for (const [name, driver] of entries) {
+    if (!/^[a-z][a-z0-9_-]{0,63}$/.test(name)) {
+      throw new Error(`Invalid storage driver name: ${name}`);
+    }
+    registry.set(name, assertDriver(name, driver));
+  }
+
+  return Object.freeze({
+    has(name) {
+      return registry.has(name);
+    },
+    get(name) {
+      const driver = registry.get(name);
+      if (!driver) {
+        const error = new Error(`Unknown storage driver: ${name}`);
+        error.code = 'STORAGE_NOT_FOUND';
+        throw error;
+      }
+      return driver;
+    },
+    names() {
+      return Object.freeze([...registry.keys()]);
+    },
+  });
+}

package/src/transaction.js

@@ -0,0 +1,46 @@
+const ISOLATION_LEVELS = new Set([
+  'READ UNCOMMITTED',
+  'READ COMMITTED',
+  'REPEATABLE READ',
+  'SERIALIZABLE',
+]);
+
+async function setIsolationLevel(connection, isolationLevel) {
+  if (!isolationLevel) return;
+  const level = String(isolationLevel).toUpperCase();
+  if (!ISOLATION_LEVELS.has(level)) {
+    throw new Error(`Unsupported transaction isolation level: ${isolationLevel}`);
+  }
+  await connection.query(`SET TRANSACTION ISOLATION LEVEL ${level}`);
+}
+
+export async function withConnectionTransaction(connection, operation, options = {}) {
+  if (!connection) throw new Error('Database connection is required');
+  if (typeof operation !== 'function') throw new Error('Transaction operation is required');
+
+  await setIsolationLevel(connection, options.isolationLevel);
+  await connection.beginTransaction();
+
+  try {
+    const result = await operation(connection);
+    await connection.commit();
+    return result;
+  } catch (error) {
+    try {
+      await connection.rollback();
+    } catch (rollbackError) {
+      error.rollbackError = rollbackError;
+    }
+    throw error;
+  }
+}
+
+export async function withTransaction(pool, operation, options = {}) {
+  const connection = await pool.getConnection();
+
+  try {
+    return await withConnectionTransaction(connection, operation, options);
+  } finally {
+    connection.release();
+  }
+}