@autonoma-ai/sdk 0.1.0 → 0.1.3

package/dist/index.js

@@ -125,6 +125,7 @@ function resolveTree(create, schema, testRunId) {
   }
   const aliases = /* @__PURE__ */ new Map();
   const ops = [];
+  const deferredUpdates = [];
   let tempCounter = 0;
   function makeTempId(model) {
     return `__temp_${model}_${tempCounter++}`;
@@ -137,9 +138,21 @@ function resolveTree(create, schema, testRunId) {
     const tempId = makeTempId(modelName);
     for (const [key, value] of Object.entries(node)) {
       if (RESERVED_KEYS.has(key)) continue;
-      const relation = relationByParentField.get(`${modelName}.${key}`);
+      const exactKey = `${modelName}.${key}`;
+      const prefixedKey = `${modelName}.${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+      let relation = relationByParentField.get(exactKey) ?? relationByParentField.get(prefixedKey) ?? void 0;
+      let matchedKey = relationByParentField.has(exactKey) ? exactKey : prefixedKey;
+      if (!relation) {
+        for (const [relKey, rel] of relationByParentField) {
+          if (relKey.startsWith(`${modelName}.`) && rel.childModel.toLowerCase() === key.toLowerCase()) {
+            relation = rel;
+            matchedKey = relKey;
+            break;
+          }
+        }
+      }
       if (relation) {
-        const isOnParent = fkOnParent.has(`${modelName}.${key}`);
+        const isOnParent = fkOnParent.has(matchedKey);
         if (isOnParent) {
           preChildren.push({ relation, value, fkOnParent: true });
         } else {
@@ -151,7 +164,8 @@ function resolveTree(create, schema, testRunId) {
         const refAlias = value._ref;
         const refTempId = aliases.get(refAlias);
         if (!refTempId) {
-          throw new Error(`_ref "${refAlias}" not found. Ensure the referenced node has _alias and is created before this one.`);
+          deferredUpdates.push({ targetTempId: tempId, model: modelName, field: key, refAlias });
+          continue;
         }
         fields[key] = refTempId;
         continue;
@@ -200,7 +214,7 @@ function resolveTree(create, schema, testRunId) {
       walkNode(modelName, nodes[i], null, null, false, i);
     }
   }
-  return { ops, aliases };
+  return { ops, deferredUpdates, aliases };
 }
 
 // src/errors.ts
@@ -257,7 +271,618 @@ var Errors = {
   }
 };
 
+// src/generated/sql-queries.ts
+var POSTGRES_COLUMNS = `SELECT
+  table_name,
+  column_name,
+  data_type,
+  udt_name,
+  is_nullable,
+  column_default
+FROM information_schema.columns
+WHERE table_schema = '{{schema}}'
+ORDER BY table_name, ordinal_position`;
+var POSTGRES_ENUMS = `SELECT t.typname AS enum_name, e.enumlabel AS enum_value
+FROM pg_type t
+JOIN pg_enum e ON t.oid = e.enumtypid
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+ORDER BY t.typname, e.enumsortorder`;
+var POSTGRES_FOREIGN_KEYS = `SELECT
+  kcu.table_name AS from_table,
+  kcu.column_name AS from_column,
+  ccu.table_name AS to_table,
+  ccu.column_name AS to_column,
+  c.is_nullable
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage ccu
+  ON tc.constraint_name = ccu.constraint_name
+  AND tc.table_schema = ccu.table_schema
+LEFT JOIN information_schema.columns c
+  ON c.table_schema = kcu.table_schema
+  AND c.table_name = kcu.table_name
+  AND c.column_name = kcu.column_name
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND tc.table_schema = '{{schema}}'
+ORDER BY kcu.table_name, kcu.ordinal_position`;
+var POSTGRES_PRIMARY_KEYS = `SELECT
+  tc.table_name,
+  kcu.column_name
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+WHERE tc.constraint_type = 'PRIMARY KEY'
+  AND tc.table_schema = '{{schema}}'
+ORDER BY tc.table_name, kcu.ordinal_position`;
+var POSTGRES_TABLES = `SELECT table_name
+FROM information_schema.tables
+WHERE table_schema = '{{schema}}'
+  AND table_type = 'BASE TABLE'
+ORDER BY table_name`;
+var MYSQL_COLUMNS = `SELECT
+  table_name,
+  column_name,
+  data_type,
+  column_type AS udt_name,
+  is_nullable,
+  column_default
+FROM information_schema.columns
+WHERE table_schema = '{{schema}}'
+ORDER BY table_name, ordinal_position`;
+var MYSQL_ENUMS = `SELECT NULL AS enum_name, NULL AS enum_value FROM DUAL WHERE 1 = 0`;
+var MYSQL_FOREIGN_KEYS = `SELECT
+  kcu.table_name AS from_table,
+  kcu.column_name AS from_column,
+  kcu.referenced_table_name AS to_table,
+  kcu.referenced_column_name AS to_column,
+  c.is_nullable
+FROM information_schema.key_column_usage kcu
+JOIN information_schema.columns c
+  ON c.table_schema = kcu.table_schema
+  AND c.table_name = kcu.table_name
+  AND c.column_name = kcu.column_name
+WHERE kcu.referenced_table_name IS NOT NULL
+  AND kcu.table_schema = '{{schema}}'
+ORDER BY kcu.table_name, kcu.ordinal_position`;
+var MYSQL_PRIMARY_KEYS = `SELECT
+  tc.table_name,
+  kcu.column_name
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+  AND tc.table_name = kcu.table_name
+WHERE tc.constraint_type = 'PRIMARY KEY'
+  AND tc.table_schema = '{{schema}}'
+ORDER BY tc.table_name, kcu.ordinal_position`;
+var MYSQL_TABLES = `SELECT table_name
+FROM information_schema.tables
+WHERE table_schema = '{{schema}}'
+  AND table_type = 'BASE TABLE'
+ORDER BY table_name`;
+
+// src/dialect.ts
+var replaceSchema = (template, schema) => template.replace("{{schema}}", schema);
+var postgres = {
+  name: "postgres",
+  param: (i) => `$${i}`,
+  quoteId: (name) => `"${name}"`,
+  supportsReturning: true,
+  tablesSQL: (schema) => replaceSchema(POSTGRES_TABLES, schema),
+  columnsSQL: (schema) => replaceSchema(POSTGRES_COLUMNS, schema),
+  primaryKeysSQL: (schema) => replaceSchema(POSTGRES_PRIMARY_KEYS, schema),
+  foreignKeysSQL: (schema) => replaceSchema(POSTGRES_FOREIGN_KEYS, schema),
+  enumsSQL: () => POSTGRES_ENUMS
+};
+var mysql = {
+  name: "mysql",
+  param: () => "?",
+  quoteId: (name) => `\`${name}\``,
+  supportsReturning: false,
+  tablesSQL: (schema) => replaceSchema(MYSQL_TABLES, schema),
+  columnsSQL: (schema) => replaceSchema(MYSQL_COLUMNS, schema),
+  primaryKeysSQL: (schema) => replaceSchema(MYSQL_PRIMARY_KEYS, schema),
+  foreignKeysSQL: (schema) => replaceSchema(MYSQL_FOREIGN_KEYS, schema),
+  enumsSQL: () => MYSQL_ENUMS
+};
+function getDialect(name = "postgres") {
+  switch (name) {
+    case "postgres":
+      return postgres;
+    case "mysql":
+      return mysql;
+    default:
+      throw new Error(`Dialect "${name}" is not yet supported. Currently only "postgres" and "mysql" are available.`);
+  }
+}
+
+// src/introspect.ts
+async function introspectDatabase(executor, dialect, config) {
+  const dbSchema = config.schema ?? (dialect.name === "mysql" ? void 0 : "public");
+  if (!dbSchema) {
+    throw new Error("MySQL requires a schema (database name). Pass it via config.schema or HandlerConfig.dbSchema.");
+  }
+  const excludeSet = new Set(config.excludeTables ?? ["_prisma_migrations"]);
+  const [tableRows, columnRows, pkRows, fkRows, enumRows] = await Promise.all([
+    executor.query(dialect.tablesSQL(dbSchema)).then(normalizeKeys),
+    executor.query(dialect.columnsSQL(dbSchema)).then(normalizeKeys),
+    executor.query(dialect.primaryKeysSQL(dbSchema)).then(normalizeKeys),
+    executor.query(dialect.foreignKeysSQL(dbSchema)).then(normalizeKeys),
+    executor.query(dialect.enumsSQL(dbSchema)).then(normalizeKeys)
+  ]);
+  const enumValues = /* @__PURE__ */ new Map();
+  for (const row of enumRows) {
+    if (!row.enum_name) continue;
+    if (!enumValues.has(row.enum_name)) enumValues.set(row.enum_name, []);
+    enumValues.get(row.enum_name).push(row.enum_value);
+  }
+  if (dialect.name === "mysql") {
+    for (const col of columnRows) {
+      const parsed = parseMySQLEnum(col.udt_name);
+      if (parsed) {
+        const enumKey = `${col.table_name}.${col.column_name}`;
+        enumValues.set(enumKey, parsed);
+      }
+    }
+  }
+  const pksByTable = /* @__PURE__ */ new Map();
+  for (const row of pkRows) {
+    if (!pksByTable.has(row.table_name)) pksByTable.set(row.table_name, /* @__PURE__ */ new Set());
+    pksByTable.get(row.table_name).add(row.column_name);
+  }
+  const userMap = config.tableNameMap ?? {};
+  const tableMap = /* @__PURE__ */ new Map();
+  const reverseTableMap = /* @__PURE__ */ new Map();
+  for (const [model, dbTable] of Object.entries(userMap)) {
+    tableMap.set(model, dbTable);
+    reverseTableMap.set(dbTable, model);
+  }
+  const dbTables = tableRows.map((r) => r.table_name).filter((t) => !excludeSet.has(t));
+  for (const dbTable of dbTables) {
+    if (reverseTableMap.has(dbTable)) continue;
+    const modelName = snakeToPascal(dbTable);
+    tableMap.set(modelName, dbTable);
+    reverseTableMap.set(dbTable, modelName);
+  }
+  const models = [];
+  const columnMaps = /* @__PURE__ */ new Map();
+  const enumTypeMaps = /* @__PURE__ */ new Map();
+  const columnsByTable = /* @__PURE__ */ new Map();
+  for (const row of columnRows) {
+    if (!columnsByTable.has(row.table_name)) columnsByTable.set(row.table_name, []);
+    columnsByTable.get(row.table_name).push(row);
+  }
+  for (const [modelName, dbTable] of tableMap) {
+    const cols = columnsByTable.get(dbTable) ?? [];
+    const pks = pksByTable.get(dbTable) ?? /* @__PURE__ */ new Set();
+    const colMap = /* @__PURE__ */ new Map();
+    const fields = [];
+    for (const col of cols) {
+      const fieldName = snakeToCamel(col.column_name);
+      colMap.set(fieldName, col.column_name);
+      let enumVals;
+      if (dialect.name === "mysql") {
+        enumVals = enumValues.get(`${col.table_name}.${col.column_name}`);
+      } else {
+        enumVals = enumValues.get(col.udt_name);
+      }
+      const type = enumVals ? `enum(${enumVals.join(",")})` : mapDataType(col.data_type, col.udt_name, dialect.name);
+      if (dialect.name === "postgres") {
+        if (enumVals) {
+          if (!enumTypeMaps.has(modelName)) enumTypeMaps.set(modelName, /* @__PURE__ */ new Map());
+          enumTypeMaps.get(modelName).set(fieldName, col.udt_name);
+        } else if (col.data_type === "jsonb" || col.udt_name === "jsonb" || col.data_type === "json" || col.udt_name === "json") {
+          if (!enumTypeMaps.has(modelName)) enumTypeMaps.set(modelName, /* @__PURE__ */ new Map());
+          const jsonType = col.data_type === "json" || col.udt_name === "json" ? "json" : "jsonb";
+          enumTypeMaps.get(modelName).set(fieldName, jsonType);
+        } else if (col.data_type.includes("timestamp") || col.udt_name === "timestamptz" || col.udt_name === "timestamp") {
+          if (!enumTypeMaps.has(modelName)) enumTypeMaps.set(modelName, /* @__PURE__ */ new Map());
+          enumTypeMaps.get(modelName).set(fieldName, col.udt_name);
+        }
+      }
+      fields.push({
+        name: fieldName,
+        type,
+        isRequired: col.is_nullable === "NO",
+        isId: pks.has(col.column_name),
+        hasDefault: col.column_default !== null
+      });
+    }
+    columnMaps.set(modelName, colMap);
+    models.push({ name: modelName, tableName: dbTable, fields });
+  }
+  const edges = [];
+  for (const fk of fkRows) {
+    const fromModel = reverseTableMap.get(fk.from_table);
+    const toModel = reverseTableMap.get(fk.to_table);
+    if (!fromModel || !toModel) continue;
+    const fromColMap = columnMaps.get(fromModel);
+    const toColMap = columnMaps.get(toModel);
+    const localField = fromColMap ? reverseGet(fromColMap, fk.from_column) ?? fk.from_column : fk.from_column;
+    const foreignField = toColMap ? reverseGet(toColMap, fk.to_column) ?? fk.to_column : fk.to_column;
+    edges.push({
+      from: fromModel,
+      to: toModel,
+      localField,
+      foreignField,
+      nullable: fk.is_nullable === "YES"
+    });
+  }
+  const relations = [];
+  for (const edge of edges) {
+    const fromDbTable = tableMap.get(edge.from);
+    const fromColMap = columnMaps.get(edge.from) ?? /* @__PURE__ */ new Map();
+    const fkDbCol = fromColMap.get(edge.localField) ?? edge.localField;
+    const fromPks = pksByTable.get(fromDbTable);
+    const isOneToOne = fromPks !== void 0 && fromPks.size === 1 && fromPks.has(fkDbCol);
+    relations.push({
+      parentModel: edge.to,
+      childModel: edge.from,
+      parentField: isOneToOne ? lowerFirst(edge.from) : pluralCamelCase(edge.from),
+      childField: edge.localField
+    });
+    relations.push({
+      parentModel: edge.from,
+      childModel: edge.to,
+      parentField: lowerFirst(edge.to),
+      childField: edge.localField
+    });
+  }
+  return {
+    schema: { models, edges, relations, scopeField: config.scopeField },
+    tableMap,
+    columnMaps,
+    enumTypeMaps
+  };
+}
+function snakeToPascal(str) {
+  return str.split("_").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function snakeToCamel(str) {
+  const pascal = snakeToPascal(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function parseMySQLEnum(columnType) {
+  if (!columnType) return null;
+  const match = columnType.match(/^enum\((.+)\)$/i);
+  if (!match) return null;
+  return match[1].split(",").map((v) => v.trim().replace(/^'|'$/g, ""));
+}
+function mapDataType(dataType, udtName, dialectName) {
+  const dt = dataType.toLowerCase();
+  if (dt === "integer" || dt === "smallint" || dt === "bigint" || dt === "int" || dt === "mediumint" || dt === "tinyint") return "Int";
+  if (dt === "numeric" || dt === "real" || dt === "double precision" || dt === "float" || dt === "double" || dt === "decimal") return "Float";
+  if (dt === "boolean" || dt === "tinyint(1)") return "Boolean";
+  if (dt === "text" || dt === "character varying" || dt === "character" || dt === "varchar" || dt === "char" || dt === "mediumtext" || dt === "longtext" || dt === "tinytext") return "String";
+  if (dt === "timestamp with time zone" || dt === "timestamp without time zone" || dt === "date" || dt === "time" || dt === "datetime" || dt === "timestamp") return "DateTime";
+  if (dt === "json" || dt === "jsonb") return "Json";
+  if (dt === "uuid") return "String";
+  if (dt === "bytea" || dt === "blob" || dt === "mediumblob" || dt === "longblob" || dt === "tinyblob" || dt === "binary" || dt === "varbinary") return "Bytes";
+  if (dt === "user-defined" && dialectName === "postgres") return udtName;
+  if (dt === "enum" || dt === "set") return udtName;
+  return dataType;
+}
+function lowerFirst(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function pluralCamelCase(modelName) {
+  const camel = lowerFirst(modelName);
+  return pluralize(camel);
+}
+function pluralize(str) {
+  if (str.endsWith("s") || str.endsWith("x") || str.endsWith("z") || str.endsWith("ch") || str.endsWith("sh")) {
+    return str + "es";
+  }
+  if (str.endsWith("y") && str.length > 1 && !isVowel(str.charAt(str.length - 2))) {
+    return str.slice(0, -1) + "ies";
+  }
+  return str + "s";
+}
+function isVowel(ch) {
+  return "aeiou".includes(ch.toLowerCase());
+}
+function normalizeKeys(rows) {
+  return rows.map((row) => {
+    if (!row || typeof row !== "object") return row;
+    const normalized = {};
+    for (const [key, val] of Object.entries(row)) {
+      normalized[key.toLowerCase()] = val;
+    }
+    return normalized;
+  });
+}
+function reverseGet(map, dbName) {
+  for (const [key, val] of map) {
+    if (val === dbName) return key;
+  }
+  return null;
+}
+
+// src/create.ts
+import { randomUUID } from "crypto";
+async function createEntities(executor, dialect, tableMap, columnMaps, spec, _context, enumTypeMaps = /* @__PURE__ */ new Map()) {
+  const results = {};
+  for (const [model, entitySpec] of Object.entries(spec)) {
+    const dbTable = tableMap.get(model);
+    if (!dbTable) throw new Error(`Unknown model "${model}". Not found in database tables.`);
+    const colMap = columnMaps.get(model) ?? /* @__PURE__ */ new Map();
+    const enumTypeMap = enumTypeMaps.get(model) ?? /* @__PURE__ */ new Map();
+    if (entitySpec.batch && entitySpec.fields.length > 0) {
+      results[model] = await insertBatch(executor, dialect, dbTable, colMap, enumTypeMap, entitySpec.fields);
+    } else {
+      const created = [];
+      for (const fields of entitySpec.fields) {
+        const [record] = await insertOne(executor, dialect, dbTable, colMap, enumTypeMap, fields);
+        if (record) created.push(record);
+      }
+      results[model] = created;
+    }
+  }
+  return results;
+}
+async function updateEntity(executor, dialect, tableMap, columnMaps, model, id, fields, enumTypeMaps = /* @__PURE__ */ new Map()) {
+  const dbTable = tableMap.get(model);
+  if (!dbTable) throw new Error(`Unknown model "${model}" for update.`);
+  const colMap = columnMaps.get(model) ?? /* @__PURE__ */ new Map();
+  const enumTypeMap = enumTypeMaps.get(model) ?? /* @__PURE__ */ new Map();
+  const setClauses = [];
+  const params = [];
+  let paramIdx = 1;
+  for (const [fieldName, value] of Object.entries(fields)) {
+    const dbCol = colMap.get(fieldName) ?? fieldName;
+    setClauses.push(`${dialect.quoteId(dbCol)} = ${castParam(dialect, paramIdx, enumTypeMap, fieldName)}`);
+    params.push(serializeValue(value, dialect));
+    paramIdx++;
+  }
+  const idCol = colMap.get("id") ?? "id";
+  params.push(id);
+  const sql = `UPDATE ${dialect.quoteId(dbTable)} SET ${setClauses.join(", ")} WHERE ${dialect.quoteId(idCol)} = ${dialect.param(paramIdx)}`;
+  await executor.query(sql, params);
+}
+async function insertOne(executor, dialect, dbTable, colMap, enumTypeMap, fields) {
+  const idFieldName = reverseGet2(colMap, findIdCol(colMap));
+  if (idFieldName && fields[idFieldName] === void 0) {
+    fields = { ...fields, [idFieldName]: randomUUID() };
+  }
+  const entries = Object.entries(fields);
+  if (entries.length === 0) {
+    const sql = `INSERT INTO ${dialect.quoteId(dbTable)} DEFAULT VALUES RETURNING *`;
+    return mapRowsBack(await executor.query(sql), colMap);
+  }
+  const dbCols = [];
+  const params = [];
+  const placeholders = [];
+  let paramIdx = 1;
+  for (const [fieldName, value] of entries) {
+    const dbCol = colMap.get(fieldName) ?? fieldName;
+    dbCols.push(dialect.quoteId(dbCol));
+    placeholders.push(castParam(dialect, paramIdx, enumTypeMap, fieldName));
+    params.push(serializeValue(value, dialect));
+    paramIdx++;
+  }
+  const colList = dbCols.join(", ");
+  const valList = placeholders.join(", ");
+  if (dialect.supportsReturning) {
+    const sql = `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES (${valList}) RETURNING *`;
+    return mapRowsBack(await executor.query(sql, params), colMap);
+  }
+  await executor.query(
+    `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES (${valList})`,
+    params
+  );
+  const idCol = findIdCol(colMap);
+  const id = fields[idFieldName ?? "id"];
+  return mapRowsBack(
+    await executor.query(
+      `SELECT * FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(idCol)} = ${dialect.param(1)}`,
+      [id]
+    ),
+    colMap
+  );
+}
+async function insertBatch(executor, dialect, dbTable, colMap, enumTypeMap, fieldsArr) {
+  if (fieldsArr.length === 0) return [];
+  const idFieldName = reverseGet2(colMap, findIdCol(colMap));
+  if (idFieldName) {
+    fieldsArr = fieldsArr.map((fields) => {
+      if (fields[idFieldName] === void 0) {
+        return { ...fields, [idFieldName]: randomUUID() };
+      }
+      return fields;
+    });
+  }
+  const fieldNames = Object.keys(fieldsArr[0]);
+  const dbCols = fieldNames.map((f) => dialect.quoteId(colMap.get(f) ?? f));
+  const colList = dbCols.join(", ");
+  const MAX_PARAMS = 32e3;
+  const chunkSize = Math.max(1, Math.floor(MAX_PARAMS / fieldNames.length));
+  const allResults = [];
+  for (let offset = 0; offset < fieldsArr.length; offset += chunkSize) {
+    const chunk = fieldsArr.slice(offset, offset + chunkSize);
+    const params = [];
+    const valueTuples = [];
+    let paramIdx = 1;
+    for (const fields of chunk) {
+      const placeholders = [];
+      for (const fieldName of fieldNames) {
+        placeholders.push(castParam(dialect, paramIdx, enumTypeMap, fieldName));
+        params.push(serializeValue(fields[fieldName], dialect));
+        paramIdx++;
+      }
+      valueTuples.push(`(${placeholders.join(", ")})`);
+    }
+    const valList = valueTuples.join(", ");
+    if (dialect.supportsReturning) {
+      const sql = `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES ${valList} RETURNING *`;
+      allResults.push(...mapRowsBack(await executor.query(sql, params), colMap));
+    } else {
+      await executor.query(
+        `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES ${valList}`,
+        params
+      );
+    }
+  }
+  return allResults;
+}
+function mapRowsBack(rows, colMap) {
+  if (colMap.size === 0) return rows;
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [fieldName, dbCol] of colMap) {
+    reverse.set(dbCol, fieldName);
+  }
+  return rows.map((row) => {
+    const mapped = {};
+    for (const [key, value] of Object.entries(row)) {
+      const fieldName = reverse.get(key) ?? key;
+      mapped[fieldName] = value;
+    }
+    return mapped;
+  });
+}
+function findIdCol(colMap) {
+  return colMap.get("id") ?? "id";
+}
+function reverseGet2(map, dbName) {
+  for (const [key, val] of map) {
+    if (val === dbName) return key;
+  }
+  return null;
+}
+function castParam(dialect, paramIdx, enumTypeMap, fieldName) {
+  const placeholder = dialect.param(paramIdx);
+  if (dialect.name === "postgres") {
+    const enumType = enumTypeMap.get(fieldName);
+    if (enumType) return `${placeholder}::${dialect.quoteId(enumType)}`;
+  }
+  return placeholder;
+}
+function serializeValue(value, dialect) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "object" && !(value instanceof Date)) {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string" && dialect.name === "mysql") {
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+      return value.replace("T", " ").replace("Z", "").replace(/\.\d+$/, "");
+    }
+  }
+  return value;
+}
+
+// src/teardown.ts
+async function teardown(executor, dialect, tableMap, columnMaps, schema, scopeValue, refs) {
+  let scopeRootModel = null;
+  for (const edge of schema.edges) {
+    if (edge.localField.toLowerCase() === schema.scopeField.toLowerCase() && edge.to !== edge.from) {
+      scopeRootModel = edge.to;
+      break;
+    }
+  }
+  const scopeFieldByModel = /* @__PURE__ */ new Map();
+  if (scopeRootModel) {
+    for (const edge of schema.edges) {
+      if (edge.to === scopeRootModel && edge.from !== scopeRootModel) {
+        scopeFieldByModel.set(edge.from, edge.localField);
+      }
+    }
+  }
+  const modelNames = schema.models.map((m) => m.name);
+  const { sorted, cycles } = topoSort(modelNames, schema.edges);
+  await executor.transaction(async (tx) => {
+    for (const cycle of cycles) {
+      const edge = findDeferrableEdge(cycle, schema.edges);
+      if (edge) {
+        const scopeFK = scopeFieldByModel.get(edge.from);
+        if (scopeFK) {
+          const dbTable = tableMap.get(edge.from);
+          const colMap = columnMaps.get(edge.from) ?? /* @__PURE__ */ new Map();
+          if (dbTable) {
+            const dbFKCol = colMap.get(edge.localField) ?? edge.localField;
+            const dbScopeCol = colMap.get(scopeFK) ?? scopeFK;
+            await tx.query(
+              `UPDATE ${dialect.quoteId(dbTable)} SET ${dialect.quoteId(dbFKCol)} = NULL WHERE ${dialect.quoteId(dbScopeCol)} = ${dialect.param(1)}`,
+              [scopeValue]
+            );
+          }
+        }
+      }
+    }
+    for (const cycle of cycles) {
+      for (const model of cycle) {
+        await deleteModel(tx, dialect, tableMap, columnMaps, model, scopeValue, scopeFieldByModel, refs);
+      }
+    }
+    const reversed = [...sorted].reverse();
+    for (const model of reversed) {
+      if (model === scopeRootModel) continue;
+      await deleteModel(tx, dialect, tableMap, columnMaps, model, scopeValue, scopeFieldByModel, refs);
+    }
+    if (scopeRootModel) {
+      const dbTable = tableMap.get(scopeRootModel);
+      const colMap = columnMaps.get(scopeRootModel) ?? /* @__PURE__ */ new Map();
+      if (dbTable) {
+        const idCol = colMap.get("id") ?? "id";
+        await tx.query(
+          `DELETE FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(idCol)} = ${dialect.param(1)}`,
+          [scopeValue]
+        );
+      }
+    }
+  });
+}
+async function deleteModel(tx, dialect, tableMap, columnMaps, model, scopeValue, scopeFieldByModel, refs) {
+  const dbTable = tableMap.get(model);
+  if (!dbTable) return;
+  const colMap = columnMaps.get(model) ?? /* @__PURE__ */ new Map();
+  const scopeFK = scopeFieldByModel.get(model);
+  if (scopeFK) {
+    const dbCol = colMap.get(scopeFK) ?? scopeFK;
+    await tx.query(
+      `DELETE FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(dbCol)} = ${dialect.param(1)}`,
+      [scopeValue]
+    );
+  } else if (refs?.[model]) {
+    const ids = refs[model].map((r) => r.id).filter((id) => typeof id === "string");
+    if (ids.length > 0) {
+      const idCol = colMap.get("id") ?? "id";
+      const placeholders = ids.map((_, i) => dialect.param(i + 1)).join(", ");
+      await tx.query(
+        `DELETE FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(idCol)} IN (${placeholders})`,
+        ids
+      );
+    }
+  }
+}
+
 // src/handler.ts
+var introspectionCache = /* @__PURE__ */ new WeakMap();
+async function getIntrospection(config) {
+  let cached = introspectionCache.get(config);
+  if (cached) return cached;
+  const dialect = getDialect(config.dialect);
+  cached = await introspectDatabase(config.executor, dialect, {
+    scopeField: config.scopeField,
+    schema: config.dbSchema,
+    tableNameMap: config.tableNameMap,
+    excludeTables: config.excludeTables
+  });
+  introspectionCache.set(config, cached);
+  return cached;
+}
+var PROTOCOL_VERSION = "1.0";
+function buildSdkMeta(config) {
+  return {
+    version: PROTOCOL_VERSION,
+    sdk: {
+      language: "typescript",
+      orm: config.sdk?.orm ?? "unknown",
+      server: config.sdk?.server ?? "unknown"
+    }
+  };
+}
 async function handleRequest(config, req) {
   try {
     if (config.sharedSecret === config.signingSecret) {
@@ -284,7 +909,7 @@ async function handleRequest(config, req) {
     if (!action) throw Errors.invalidBody("missing action");
     switch (action) {
       case "discover":
-        return handleDiscover(config);
+        return await handleDiscover(config);
       case "up":
         return await handleUp(config, body);
       case "down":
@@ -300,61 +925,85 @@ async function handleRequest(config, req) {
     return { status: 500, body: { error: message, code: "INTERNAL_ERROR" } };
   }
 }
-function handleDiscover(config) {
-  const schema = config.adapter.getSchema();
-  return { status: 200, body: { schema } };
+async function handleDiscover(config) {
+  const { schema } = await getIntrospection(config);
+  return { status: 200, body: { ...buildSdkMeta(config), schema } };
 }
 async function handleUp(config, body) {
   const create = body.create;
   if (!create) throw Errors.invalidBody('missing "create" in request body');
   const testRunId = body.testRunId ?? crypto.randomUUID();
-  const schema = config.adapter.getSchema();
+  const { schema, tableMap, columnMaps, enumTypeMaps } = await getIntrospection(config);
+  const dialect = getDialect(config.dialect);
   const tree = resolveTree(create, schema, testRunId);
   const refs = {};
   const idMap = /* @__PURE__ */ new Map();
-  let i = 0;
-  while (i < tree.ops.length) {
-    const op = tree.ops[i];
-    const model = op.model;
-    const batch = [op];
-    while (i + 1 < tree.ops.length && tree.ops[i + 1].model === model && tree.ops[i + 1].batch === op.batch) {
-      i++;
-      batch.push(tree.ops[i]);
-    }
-    const resolvedFields = batch.map((b) => {
-      const fields = { ...b.fields };
-      delete fields.id;
-      for (const [key, value] of Object.entries(fields)) {
-        if (typeof value === "string" && value.startsWith("__temp_")) {
-          const realId = idMap.get(value);
-          if (realId) fields[key] = realId;
-        }
+  await config.executor.transaction(async (tx) => {
+    let i = 0;
+    while (i < tree.ops.length) {
+      const op = tree.ops[i];
+      const model = op.model;
+      const batch = [op];
+      while (i + 1 < tree.ops.length && tree.ops[i + 1].model === model && tree.ops[i + 1].batch === op.batch) {
+        i++;
+        batch.push(tree.ops[i]);
       }
-      const scopeEdge = schema.edges.find(
-        (e) => e.from === model && e.localField.toLowerCase() === schema.scopeField.toLowerCase() && e.from !== e.to
-      );
-      if (scopeEdge && !(scopeEdge.localField in fields)) {
-        const scopeVal = detectScopeValue(refs, schema.scopeField);
-        if (scopeVal) fields[scopeEdge.localField] = scopeVal;
+      const modelInfo = schema.models.find((m) => m.name === model);
+      const resolvedFields = batch.map((b) => {
+        const fields = { ...b.fields };
+        delete fields.id;
+        for (const [key, value] of Object.entries(fields)) {
+          if (typeof value === "string" && value.startsWith("__temp_")) {
+            const realId = idMap.get(value);
+            if (realId) fields[key] = realId;
+          }
+        }
+        const scopeEdge = schema.edges.find(
+          (e) => e.from === model && e.localField.toLowerCase() === schema.scopeField.toLowerCase() && e.from !== e.to
+        );
+        if (scopeEdge && !(scopeEdge.localField in fields)) {
+          const scopeVal = detectScopeValue(refs, schema.scopeField);
+          if (scopeVal) fields[scopeEdge.localField] = scopeVal;
+        }
+        if (modelInfo) {
+          for (const field of modelInfo.fields) {
+            if (field.isRequired && !field.hasDefault && !field.isId && !(field.name in fields)) {
+              if (field.type === "DateTime") {
+                fields[field.name] = /* @__PURE__ */ new Date();
+              }
+            }
+          }
+        }
+        return fields;
+      });
+      const spec = {
+        [model]: { count: resolvedFields.length, fields: resolvedFields, batch: op.batch }
+      };
+      const context = { testRunId, refs };
+      const created = await createEntities(tx, dialect, tableMap, columnMaps, spec, context, enumTypeMaps);
+      const records = created[model] ?? [];
+      if (!refs[model]) refs[model] = [];
+      refs[model].push(...records);
+      for (let j = 0; j < batch.length; j++) {
+        const record = records[j];
+        if (record && typeof record.id === "string") {
+          idMap.set(batch[j].tempId, record.id);
+        }
       }
-      return fields;
-    });
-    const spec = {
-      [model]: { count: resolvedFields.length, fields: resolvedFields, batch: op.batch }
-    };
-    const context = { testRunId, refs };
-    const created = await config.adapter.createEntities(spec, context);
-    const records = created[model] ?? [];
-    if (!refs[model]) refs[model] = [];
-    refs[model].push(...records);
-    for (let j = 0; j < batch.length; j++) {
-      const record = records[j];
-      if (record && typeof record.id === "string") {
-        idMap.set(batch[j].tempId, record.id);
+      i++;
+    }
+    for (const deferred of tree.deferredUpdates) {
+      const realTargetId = idMap.get(deferred.targetTempId);
+      const refTempId = tree.aliases.get(deferred.refAlias);
+      const realRefId = refTempId ? idMap.get(refTempId) : void 0;
+      if (!realTargetId || !realRefId) {
+        throw new Error(
+          `_ref "${deferred.refAlias}" could not be resolved. Ensure the referenced node has _alias defined in the scenario.`
+        );
       }
+      await updateEntity(tx, dialect, tableMap, columnMaps, deferred.model, realTargetId, { [deferred.field]: realRefId }, enumTypeMaps);
     }
-    i++;
-  }
+  });
   const scopeValue = detectScopeValue(refs, schema.scopeField) ?? testRunId;
   const firstUser = findFirstUser(refs);
   let auth = { token: "" };
@@ -365,7 +1014,7 @@ async function handleUp(config, body) {
     { refs, testRunId: scopeValue, environment: "" },
     config.signingSecret
   );
-  return { status: 200, body: { auth, refs, refsToken } };
+  return { status: 200, body: { ...buildSdkMeta(config), auth, refs, refsToken } };
 }
 async function handleDown(config, body) {
   const refsToken = body.refsToken;
@@ -377,8 +1026,10 @@ async function handleDown(config, body) {
     const message = err instanceof Error ? err.message : "invalid token";
     throw Errors.invalidRefsToken(message);
   }
-  await config.adapter.teardown(payload.testRunId, payload.refs);
-  return { status: 200, body: { ok: true } };
+  const { schema, tableMap, columnMaps } = await getIntrospection(config);
+  const dialect = getDialect(config.dialect);
+  await teardown(config.executor, dialect, tableMap, columnMaps, schema, payload.testRunId, payload.refs);
+  return { status: 200, body: { ...buildSdkMeta(config), ok: true } };
 }
 function findFirstUser(refs) {
   for (const [model, records] of Object.entries(refs)) {
@@ -422,11 +1073,15 @@ function sortReplacer(_key, value) {
 }
 
 // src/check.ts
-async function checkScenario(adapter, scenario, options) {
+async function checkScenario(executor, scenario, options) {
   const sharedSecret = options?.sharedSecret ?? "autonoma-check-shared";
   const signingSecret = options?.signingSecret ?? "autonoma-check-signing";
   const config = {
-    adapter,
+    executor,
+    scopeField: options?.scopeField ?? "organizationId",
+    dialect: options?.dialect,
+    dbSchema: options?.dbSchema,
+    tableNameMap: options?.tableNameMap,
     sharedSecret,
     signingSecret,
     auth: options?.auth ?? (async () => ({ token: "check-token" }))
@@ -468,41 +1123,42 @@ async function checkScenario(adapter, scenario, options) {
   }
   return { valid: true, phase: "ok", errors: [], timing: { upMs, downMs } };
 }
-async function checkAllScenarios(adapter, scenarios, options) {
+async function checkAllScenarios(executor, scenarios, options) {
   const results = [];
   for (const scenario of scenarios) {
-    results.push(await checkScenario(adapter, scenario, options));
+    results.push(await checkScenario(executor, scenario, options));
   }
   return results;
 }
 function suggestFix(errorMsg) {
-  if (errorMsg.includes("Unique constraint failed")) {
-    const match = errorMsg.match(/fields: \(`(.+?)`\)/);
+  if (errorMsg.includes("Unique constraint failed") || errorMsg.includes("unique constraint")) {
+    const match = errorMsg.match(/fields: \(`(.+?)`\)/) ?? errorMsg.match(/constraint "(.+?)"/);
     if (match) return `Unique constraint on (${match[1]}). Add {{testRunId}} or {{index}} to make values unique.`;
     return "Unique constraint violation. Make field values unique across instances.";
   }
-  if (errorMsg.includes("Foreign key constraint")) {
+  if (errorMsg.includes("Foreign key constraint") || errorMsg.includes("foreign key")) {
     return "A referenced record does not exist. Check that parent entities are nested correctly.";
   }
-  if (errorMsg.includes("Unknown argument")) {
-    const match = errorMsg.match(/Unknown argument `(\w+)`/);
-    if (match) return `Field "${match[1]}" does not exist on this model. Remove it.`;
-  }
-  if (errorMsg.includes("must not be null")) {
+  if (errorMsg.includes("null value in column") || errorMsg.includes("must not be null")) {
     return "A required field is null. Add it to the node with a value.";
   }
   return "";
 }
 export {
+  PROTOCOL_VERSION,
   checkAllScenarios,
   checkScenario,
+  createEntities,
   findDeferrableEdge,
   fingerprint,
+  getDialect,
   handleRequest,
+  introspectDatabase,
   resolveTemplate,
   resolveTree,
   signBody,
   signRefs,
+  teardown,
   topoSort,
   verifyRefs,
   verifySignature