rado 1.0.13 → 1.0.15

package/dist/core/Column.js

@@ -27,7 +27,7 @@ var Column = class _Column {
   default(value) {
     return new _Column({
       ...getData(this),
-      defaultValue: input(value)
+      defaultValue: input(value).inlineValues()
     });
   }
   defaultNow() {

package/dist/core/Selection.js

@@ -91,21 +91,18 @@ var Selection = class {
         names.add(exprName);
         if (hasField(input)) {
           const field = getField(input);
-          if (field.fieldName === exprName) return expr;
+          if (field.fieldName === exprName) return [expr];
         }
-        return sql`${expr.forSelection()} as ${sql.identifier(exprName)}`;
+        return [sql`${expr.forSelection()} as ${sql.identifier(exprName)}`];
       }
-      return expr;
+      return [expr];
     }
-    return sql.join(
-      Object.entries(input).map(
-        ([name2, value]) => this.#selectionToSql(value, names, name2)
-      ),
-      sql`, `
+    return Object.entries(input).flatMap(
+      ([name2, value]) => this.#selectionToSql(value, names, name2)
     );
   }
   get [internalSql]() {
-    return this.#selectionToSql(this.input, /* @__PURE__ */ new Set());
+    return sql.join(this.#selectionToSql(this.input, /* @__PURE__ */ new Set()), sql`, `);
   }
   join(right, operator) {
     return this;

package/dist/core/query/Insert.js

@@ -3,6 +3,7 @@ import {
   getData,
   getQuery,
   getTable,
+  hasSql,
   internalData,
   internalQuery,
   internalSelection
@@ -93,8 +94,11 @@ var InsertInto = class {
           Object.entries(table.columns).map(([key, column]) => {
             const value = row[key];
             const { $default, mapToDriverValue } = getData(column);
-            if (value !== void 0)
+            if (value !== void 0) {
+              if (value && typeof value === "object" && hasSql(value))
+                return value;
               return input(mapToDriverValue?.(value) ?? value);
+            }
             if ($default) return $default();
             return defaultKeyword;
           }),

package/dist/core/query/Update.js

@@ -2,6 +2,7 @@
 import {
   getData,
   getTable,
+  hasSql,
   internalData,
   internalQuery,
   internalSelection
@@ -31,9 +32,8 @@ var UpdateTable = class _UpdateTable extends Update {
       Object.entries(values).map(([key, value]) => {
         const column = getTable(table).columns[key];
         const { mapToDriverValue } = getData(column);
-        return sql`${sql.identifier(key)} = ${input(
-          mapToDriverValue?.(value) ?? value
-        )}`;
+        const expr = value && typeof value === "object" && hasSql(value) ? value : input(mapToDriverValue?.(value) ?? value);
+        return sql`${sql.identifier(key)} = ${expr}`;
       }),
       sql`, `
     );

package/dist/mysql/diff.js

@@ -1,7 +1,203 @@
 // src/mysql/diff.ts
+import { getData, getTable } from "../core/Internal.js";
+import { schema } from "../core/Schema.js";
+import { sql } from "../core/Sql.js";
+import { eq } from "../core/expr/Conditions.js";
+import { txGenerator } from "../universal.js";
+import * as column from "./columns.js";
 import { mysqlDialect } from "./dialect.js";
+var ns = schema("information_schema");
+var Information = ns.table("columns", {
+  table_name: column.text().notNull(),
+  column_name: column.text().notNull(),
+  column_type: column.text().notNull(),
+  is_nullable: column.text().notNull(),
+  column_default: column.text(),
+  extra: column.text().notNull(),
+  table_schema: column.text().notNull()
+});
+var Statistics = ns.table("statistics", {
+  table_name: column.text().notNull(),
+  column_name: column.text().notNull(),
+  index_name: column.text().notNull(),
+  non_unique: column.integer().notNull(),
+  seq_in_index: column.integer().notNull(),
+  table_schema: column.text().notNull()
+});
+var TableConstraints = ns.table("table_constraints", {
+  constraint_name: column.text().notNull(),
+  table_name: column.text().notNull(),
+  constraint_type: column.text().notNull(),
+  table_schema: column.text().notNull()
+});
+var inline = (sql2) => mysqlDialect.inline(sql2);
 var mysqlDiff = (hasTable) => {
-  throw new Error("Diffing for MySQL is not yet implemented");
+  return txGenerator(function* (tx) {
+    const tableApi = getTable(hasTable);
+    const stmts = [];
+    const columnInfo = yield* tx.select({
+      name: Information.column_name,
+      type: Information.column_type,
+      notNull: eq(Information.is_nullable, "NO"),
+      defaultValue: Information.column_default,
+      extra: Information.extra
+    }).from(Information).where(
+      eq(Information.table_name, tableApi.name),
+      eq(Information.table_schema, sql`database()`)
+    );
+    const indexInfo = yield* tx.select({
+      index_name: Statistics.index_name,
+      column_name: Statistics.column_name,
+      non_unique: Statistics.non_unique,
+      seq_in_index: Statistics.seq_in_index
+    }).from(Statistics).where(
+      eq(Statistics.table_name, tableApi.name),
+      eq(Statistics.table_schema, sql`database()`)
+    ).orderBy(Statistics.index_name, Statistics.seq_in_index);
+    const indexMap = /* @__PURE__ */ new Map();
+    for (const index of indexInfo) {
+      if (!indexMap.has(index.index_name)) {
+        indexMap.set(index.index_name, []);
+      }
+      indexMap.get(index.index_name).push(index.column_name);
+    }
+    const localColumns = new Map(
+      columnInfo.map((column2) => {
+        let type = column2.type.toLowerCase();
+        const isAutoIncrement = column2.extra.toLowerCase().includes("auto_increment");
+        if (isAutoIncrement) {
+          if (type.includes("bigint")) type = "bigserial";
+          else if (type.includes("smallint")) type = "smallserial";
+          else type = "serial";
+        }
+        return [
+          column2.name,
+          {
+            type: sql.unsafe(type),
+            notNull: column2.notNull && !isAutoIncrement,
+            defaultValue: column2.defaultValue && !isAutoIncrement ? sql.unsafe(column2.defaultValue) : void 0
+          }
+        ];
+      })
+    );
+    const schemaColumns = new Map(
+      Object.entries(tableApi.columns).map(([name, column2]) => {
+        const columnApi = getData(column2);
+        return [columnApi.name ?? name, columnApi];
+      })
+    );
+    const columnNames = /* @__PURE__ */ new Set([
+      ...localColumns.keys(),
+      ...schemaColumns.keys()
+    ]);
+    for (const columnName of columnNames) {
+      const alterTable = sql.identifier(tableApi.name);
+      const column2 = sql.identifier(columnName);
+      const localInstruction = localColumns.get(columnName);
+      const schemaInstruction = schemaColumns.get(columnName);
+      if (!schemaInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable,
+            dropColumn: column2
+          })
+        );
+      } else if (!localInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable,
+            addColumn: [column2, sql.chunk("emitColumn", schemaInstruction)]
+          })
+        );
+      } else {
+        if (inline(localInstruction.type) !== inline(schemaInstruction.type)) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              modifyColumn: [column2, schemaInstruction.type]
+            })
+          );
+        }
+        if (Boolean(localInstruction.notNull) !== Boolean(schemaInstruction.notNull)) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              modifyColumn: [
+                column2,
+                schemaInstruction.notNull ? sql`${schemaInstruction.type} not null` : sql`${schemaInstruction.type} null`
+              ]
+            })
+          );
+        }
+        const localDefault = localInstruction.defaultValue;
+        const schemaDefault = schemaInstruction.defaultValue;
+        const localDefaultStr = localDefault && inline(localDefault);
+        const schemaDefaultStr = schemaDefault && inline(schemaDefault);
+        if (localDefaultStr !== schemaDefaultStr) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              alterColumn: [
+                column2,
+                schemaDefault ? sql`set default ${schemaDefault}` : sql`drop default`
+              ]
+            })
+          );
+        }
+      }
+    }
+    const localIndexes = new Map(
+      Array.from(indexMap.entries()).filter(([name]) => name !== "PRIMARY").map(([name, columns]) => {
+        return [
+          name,
+          sql`index ${sql.identifier(name)} (${sql.join(columns.map(sql.identifier), sql`, `)})`
+        ];
+      })
+    );
+    const schemaIndexes = new Map(
+      Object.entries(tableApi.indexes()).map(([name, index]) => {
+        const indexApi = getData(index);
+        return [name, indexApi.toSql(tableApi.name, name, false)];
+      })
+    );
+    const indexNames = /* @__PURE__ */ new Set([
+      ...localIndexes.keys(),
+      ...schemaIndexes.keys()
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = localIndexes.get(indexName);
+      const schemaInstruction = schemaIndexes.get(indexName);
+      if (!schemaInstruction) {
+        stmts.unshift(
+          sql.query({
+            alterTable: sql.identifier(tableApi.name),
+            dropIndex: sql.identifier(indexName)
+          })
+        );
+      } else if (!localInstruction) {
+        stmts.push(schemaInstruction);
+      } else if (inline(localInstruction) !== inline(schemaInstruction)) {
+        if (indexName === "PRIMARY") {
+          stmts.unshift(
+            sql.query({
+              alterTable: sql.identifier(tableApi.name),
+              dropPrimaryKey: true
+            })
+          );
+          stmts.push(schemaInstruction);
+        } else {
+          stmts.unshift(
+            sql.query({
+              alterTable: sql.identifier(tableApi.name),
+              dropIndex: sql.identifier(indexName)
+            })
+          );
+          stmts.push(schemaInstruction);
+        }
+      }
+    }
+    return stmts.map(inline);
+  });
 };
 export {
   mysqlDiff

package/dist/sqlite/diff.js

@@ -23,9 +23,9 @@ var SqliteMaster = table("SqliteMaster", {
   sql: column.text().notNull()
 });
 var inline = (sql2) => sqliteDialect.inline(sql2);
-var sqliteDiff = (hasTable) => {
+var sqliteDiff = (targetTable) => {
   return txGenerator(function* (tx) {
-    const tableApi = getTable(hasTable);
+    const tableApi = getTable(targetTable);
     const columnInfo = yield* tx.select(TableInfo).from(sql`pragma_table_info(${sql.inline(tableApi.name)}) as "TableInfo"`);
     const indexInfo = yield* tx.select(SqliteMaster).from(sql`sqlite_master as "SqliteMaster"`).where(
       eq(SqliteMaster.tbl_name, tableApi.name),
@@ -57,7 +57,7 @@ var sqliteDiff = (hasTable) => {
       })
     );
     const localIndexes = new Map(
-      indexInfo.map((index) => [index.name, index.sql])
+      indexInfo.filter((index) => !index.name.startsWith("sqlite_autoindex_")).map((index) => [index.name, index.sql])
     );
     const schemaIndexes = new Map(
       Object.entries(tableApi.indexes()).map(([name, index]) => {
@@ -94,6 +94,25 @@ var sqliteDiff = (hasTable) => {
         return recreate();
       }
     }
+    const indexNames = /* @__PURE__ */ new Set([
+      ...localIndexes.keys(),
+      ...schemaIndexes.keys()
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = localIndexes.get(indexName);
+      const schemaInstruction = schemaIndexes.get(indexName);
+      const dropLocal = sql.query({
+        dropIndex: sql.identifier(indexName)
+      });
+      if (!schemaInstruction) {
+        stmts.unshift(dropLocal);
+      } else if (schemaInstruction && !localInstruction) {
+        stmts.push(sql.unsafe(schemaInstruction));
+      } else if (schemaInstruction && localInstruction !== schemaInstruction) {
+        stmts.unshift(dropLocal);
+        stmts.push(sql.unsafe(schemaInstruction));
+      }
+    }
     try {
       yield* txGenerator(function* (sp) {
         yield* sp.batch(stmts);
@@ -112,43 +131,28 @@ var sqliteDiff = (hasTable) => {
         return recreate();
       }
     }
-    const indexNames = /* @__PURE__ */ new Set([
-      ...localIndexes.keys(),
-      ...schemaIndexes.keys()
-    ]);
-    for (const indexName of indexNames) {
-      const localInstruction = localIndexes.get(indexName);
-      const schemaInstruction = schemaIndexes.get(indexName);
-      const dropLocal = sql.query({
-        dropIndex: sql.identifier(indexName),
-        on: sql.identifier(tableApi.name)
-      });
-      if (!schemaInstruction) {
-        stmts.unshift(dropLocal);
-      } else if (!localInstruction) {
-        stmts.push(sql.unsafe(schemaInstruction));
-      } else if (localInstruction !== schemaInstruction) {
-        stmts.unshift(dropLocal);
-        stmts.push(sql.unsafe(schemaInstruction));
-      }
-    }
     return stmts.map(inline);
     function recreate() {
       const tempName = `new_${tableApi.name}`;
       const tempTable = table(tempName, tableApi.columns);
-      const missingColumns = Array.from(columnNames).filter(
-        (name) => !localColumns.has(name)
+      const missingColumns = new Set(
+        Array.from(columnNames).filter((name) => !localColumns.has(name))
+      );
+      const selection = Object.fromEntries(
+        Object.entries(tableApi.columns).map(([name, column2]) => {
+          const columnApi = getData(column2);
+          const key = columnApi.name ?? name;
+          if (missingColumns.has(key))
+            return [name, columnApi.defaultValue ?? sql`null`];
+          return [name, targetTable[name]];
+        })
       );
-      const selection = { ...hasTable };
-      for (const name of missingColumns) {
-        selection[name] = getData(tableApi.columns[name]).defaultValue ?? sql`null`;
-      }
       return [
         // Create a new temporary table with the new definition
         tableApi.createTable(tempName),
         // Copy the data from the old table to the new table
         getQuery(
-          tx.insert(tempTable).select(tx.select(selection).from(hasTable))
+          tx.insert(tempTable).select(tx.select(selection).from(targetTable))
         ),
         // Drop the old table
         sql.query({ dropTable: sql.identifier(tableApi.name) }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -29,7 +29,7 @@
     "@alinea/suite": "^0.4.0",
     "@biomejs/biome": "^1.8.3",
     "@cloudflare/workers-types": "^4.20230628.0",
-    "@electric-sql/pglite": "^0.1.5",
+    "@electric-sql/pglite": "^0.2.12",
     "@libsql/client": "^0.10.0",
     "@miniflare/d1": "^2.14.2",
     "@miniflare/shared": "^2.14.2",