effect-start 0.23.0 → 0.25.0

package/dist/SqlIntrospect.js

@@ -1,9 +1,7 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import * as Sql from "./Sql.js";
-// ---------------------------------------------------------------------------
-// SQLite
-// ---------------------------------------------------------------------------
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import * as Sql from "./sql/Sql.js"
+
 const sqliteColumns = `
   SELECT
     '' as tableSchema,
@@ -21,7 +19,8 @@ const sqliteColumns = `
   WHERE m.type = 'table'
     AND m.name NOT LIKE 'sqlite_%'
   ORDER BY m.name, p.cid
-`;
+`
+
 const sqliteForeignKeys = `
   SELECT
     '' as constraintName,
@@ -38,7 +37,8 @@ const sqliteForeignKeys = `
   WHERE m.type = 'table'
     AND m.name NOT LIKE 'sqlite_%'
   ORDER BY m.name, fk.seq
-`;
+`
+
 const sqliteIndexes = `
   SELECT
     '' as tableSchema,
@@ -53,10 +53,8 @@ const sqliteIndexes = `
   WHERE m.type = 'table'
     AND m.name NOT LIKE 'sqlite_%'
   ORDER BY m.name, il.name, ii.seqno
-`;
-// ---------------------------------------------------------------------------
-// PostgreSQL
-// ---------------------------------------------------------------------------
+`
+
 const postgresColumns = `
   SELECT
     c.table_schema as "tableSchema",
@@ -83,7 +81,8 @@ const postgresColumns = `
     AND c.column_name = pk.column_name
   WHERE c.table_schema NOT IN ('information_schema', 'pg_catalog')
   ORDER BY c.table_schema, c.table_name, c.ordinal_position
-`;
+`
+
 const postgresForeignKeys = `
   SELECT
     tc.constraint_name as "constraintName",
@@ -108,7 +107,8 @@ const postgresForeignKeys = `
   WHERE tc.constraint_type = 'FOREIGN KEY'
     AND tc.table_schema NOT IN ('information_schema', 'pg_catalog')
   ORDER BY tc.table_schema, tc.table_name, kcu.ordinal_position
-`;
+`
+
 const postgresIndexes = `
   SELECT
     n.nspname as "tableSchema",
@@ -125,10 +125,8 @@ const postgresIndexes = `
     AND a.attnum = ANY(ix.indkey)
   WHERE n.nspname NOT IN ('information_schema', 'pg_catalog')
   ORDER BY n.nspname, t.relname, i.relname, array_position(ix.indkey, a.attnum)
-`;
-// ---------------------------------------------------------------------------
-// SQL Server (MSSQL)
-// ---------------------------------------------------------------------------
+`
+
 const mssqlColumns = `
   SELECT
     s.name as tableSchema,
@@ -154,7 +152,8 @@ const mssqlColumns = `
   ) pk ON c.object_id = pk.object_id AND c.column_id = pk.column_id
   WHERE t.is_ms_shipped = 0
   ORDER BY s.name, t.name, c.column_id
-`;
+`
+
 const mssqlForeignKeys = `
   SELECT
     fk.name as constraintName,
@@ -176,7 +175,8 @@ const mssqlForeignKeys = `
   JOIN sys.columns rc ON fkc.referenced_object_id = rc.object_id AND fkc.referenced_column_id = rc.column_id
   WHERE t.is_ms_shipped = 0
   ORDER BY s.name, t.name, fkc.constraint_column_id
-`;
+`
+
 const mssqlIndexes = `
   SELECT
     s.name as tableSchema,
@@ -195,272 +195,321 @@ const mssqlIndexes = `
     AND i.is_primary_key = 0
     AND ic.is_included_column = 0
   ORDER BY s.name, t.name, i.name, ic.key_ordinal
-`;
+`
+
 const dialectQueries = {
-    sqlite: { columns: sqliteColumns, foreignKeys: sqliteForeignKeys, indexes: sqliteIndexes },
-    postgres: {
-        columns: postgresColumns,
-        foreignKeys: postgresForeignKeys,
-        indexes: postgresIndexes,
-    },
-    mssql: { columns: mssqlColumns, foreignKeys: mssqlForeignKeys, indexes: mssqlIndexes },
-};
-// ---------------------------------------------------------------------------
-// Introspect
-// ---------------------------------------------------------------------------
+  sqlite: { columns: sqliteColumns, foreignKeys: sqliteForeignKeys, indexes: sqliteIndexes },
+  postgres: {
+    columns: postgresColumns,
+    foreignKeys: postgresForeignKeys,
+    indexes: postgresIndexes,
+  },
+  mssql: { columns: mssqlColumns, foreignKeys: mssqlForeignKeys, indexes: mssqlIndexes },
+}
+
 const singleColumnIndexes = (indexes) => {
-    const countByIndex = new Map();
-    for (const idx of indexes) {
-        const key = `${idx.tableSchema}.${idx.tableName}.${idx.indexName}`;
-        const existing = countByIndex.get(key);
-        if (existing) {
-            existing.count++;
-        }
-        else {
-            countByIndex.set(key, { count: 1, columnName: idx.columnName });
-        }
+  const countByIndex = new Map()
+  for (const idx of indexes) {
+    const key = `${idx.tableSchema}.${idx.tableName}.${idx.indexName}`
+    const existing = countByIndex.get(key)
+    if (existing) {
+      existing.count++
+    } else {
+      countByIndex.set(key, { count: 1, columnName: idx.columnName })
     }
-    const result = new Set();
-    for (const [key, entry] of countByIndex) {
-        if (entry.count === 1) {
-            const tableKey = key.substring(0, key.lastIndexOf("."));
-            result.add(`${tableKey}.${entry.columnName}`);
-        }
+  }
+  const result = new Set()
+  for (const [key, entry] of countByIndex) {
+    if (entry.count === 1) {
+      const tableKey = key.substring(0, key.lastIndexOf("."))
+      result.add(`${tableKey}.${entry.columnName}`)
     }
-    return result;
-};
-const groupByTable = (columns, foreignKeys, indexes) => {
-    const sortable = singleColumnIndexes(indexes);
-    const tableMap = new Map();
-    for (const col of columns) {
-        const key = `${col.tableSchema}.${col.tableName}`;
-        const fullCol = {
-            ...col,
-            isSortable: col.isPrimaryKey || sortable.has(`${key}.${col.columnName}`),
-        };
-        const existing = tableMap.get(key);
-        if (existing) {
-            ;
-            existing.columns.push(fullCol);
-        }
-        else {
-            tableMap.set(key, {
-                tableSchema: col.tableSchema,
-                tableName: col.tableName,
-                columns: [fullCol],
-                foreignKeys: [],
-                indexes: [],
-            });
-        }
+  }
+  return result
+}
+
+const groupByTable = (
+  columns,
+  foreignKeys,
+  indexes,
+) => {
+  const sortable = singleColumnIndexes(indexes)
+  const tableMap = new Map()
+  for (const col of columns) {
+    const key = `${col.tableSchema}.${col.tableName}`
+    const fullCol = {
+      ...col,
+      isSortable: col.isPrimaryKey || sortable.has(`${key}.${col.columnName}`),
     }
-    for (const fk of foreignKeys) {
-        const key = `${fk.tableSchema}.${fk.tableName}`;
-        const table = tableMap.get(key);
-        if (table) {
-            ;
-            table.foreignKeys.push(fk);
-        }
+    const existing = tableMap.get(key)
+    if (existing) {
+      ;(existing.columns).push(fullCol)
+    } else {
+      tableMap.set(key, {
+        tableSchema: col.tableSchema,
+        tableName: col.tableName,
+        columns: [fullCol],
+        foreignKeys: [],
+        indexes: [],
+      })
     }
-    for (const idx of indexes) {
-        const key = `${idx.tableSchema}.${idx.tableName}`;
-        const table = tableMap.get(key);
-        if (table) {
-            ;
-            table.indexes.push(idx);
-        }
+  }
+  for (const fk of foreignKeys) {
+    const key = `${fk.tableSchema}.${fk.tableName}`
+    const table = tableMap.get(key)
+    if (table) {
+      ;(table.foreignKeys).push(fk)
     }
-    return Array.from(tableMap.values());
-};
-const normalizeBooleans = (columns) => columns.map((c) => ({
+  }
+  for (const idx of indexes) {
+    const key = `${idx.tableSchema}.${idx.tableName}`
+    const table = tableMap.get(key)
+    if (table) {
+      ;(table.indexes).push(idx)
+    }
+  }
+  return Array.from(tableMap.values())
+}
+
+const normalizeBooleans = (columns) =>
+  columns.map((c) => ({
     ...c,
     isNullable: Boolean(c.isNullable),
     isPrimaryKey: Boolean(c.isPrimaryKey),
     isAutoIncrement: Boolean(c.isAutoIncrement),
-}));
-export const introspect = (dialect, options) => Effect.gen(function* () {
-    const sql = yield* Sql.SqlClient;
-    const q = dialectQueries[dialect];
-    const columns = normalizeBooleans(yield* sql.unsafe(q.columns));
-    const foreignKeys = options?.foreignKeys !== false ? yield* sql.unsafe(q.foreignKeys) : [];
-    const indexes = options?.indexes !== false
+  }))
+
+export const introspect = (
+  dialect,
+  options,
+) =>
+  Effect.gen(function* () {
+    const sql = yield* Sql.SqlClient
+    const q = dialectQueries[dialect]
+    const columns = normalizeBooleans(yield* sql.unsafe(q.columns))
+    const foreignKeys =
+      options?.foreignKeys !== false ? yield* sql.unsafe(q.foreignKeys) : []
+    const indexes =
+      options?.indexes !== false
         ? (yield* sql.unsafe(q.indexes)).map((i) => ({
             ...i,
             isUnique: Boolean(i.isUnique),
-        }))
-        : [];
-    return { tables: groupByTable(columns, foreignKeys, indexes) };
-});
-// ---------------------------------------------------------------------------
-// Column → Schema mapping
-// ---------------------------------------------------------------------------
+          }))
+        : []
+    return { tables: groupByTable(columns, foreignKeys, indexes) }
+  })
+
 const dataTypeToSchema = (dataType) => {
-    const t = dataType.toLowerCase();
-    if (t === "integer" ||
-        t === "int" ||
-        t === "int4" ||
-        t === "int8" ||
-        t === "smallint" ||
-        t === "tinyint" ||
-        t === "mediumint" ||
-        t === "bigint" ||
-        t === "int2")
-        return Schema.Number;
-    if (t === "real" ||
-        t === "double" ||
-        t === "double precision" ||
-        t === "float" ||
-        t === "float4" ||
-        t === "float8" ||
-        t === "numeric" ||
-        t === "decimal" ||
-        t === "money" ||
-        t === "smallmoney")
-        return Schema.Number;
-    if (t === "text" ||
-        t === "varchar" ||
-        t === "char" ||
-        t === "nchar" ||
-        t === "nvarchar" ||
-        t === "ntext" ||
-        t === "character varying" ||
-        t === "character" ||
-        t === "bpchar" ||
-        t === "uuid" ||
-        t === "citext" ||
-        t === "name" ||
-        t === "xml")
-        return Schema.String;
-    if (t === "boolean" || t === "bool" || t === "bit")
-        return Schema.Union(Schema.Boolean, Schema.Number);
-    if (t === "timestamp" ||
-        t === "timestamptz" ||
-        t === "timestamp with time zone" ||
-        t === "timestamp without time zone" ||
-        t === "date" ||
-        t === "datetime" ||
-        t === "datetime2" ||
-        t === "smalldatetime" ||
-        t === "datetimeoffset" ||
-        t === "time")
-        return Schema.String;
-    if (t === "json" || t === "jsonb")
-        return Schema.Unknown;
-    if (t === "blob" || t === "bytea" || t === "varbinary" || t === "binary" || t === "image")
-        return null;
-    return null;
-};
+  const t = dataType.toLowerCase()
+  if (
+    t === "integer" ||
+    t === "int" ||
+    t === "int4" ||
+    t === "int8" ||
+    t === "smallint" ||
+    t === "tinyint" ||
+    t === "mediumint" ||
+    t === "bigint" ||
+    t === "int2"
+  )
+    return Schema.Number
+  if (
+    t === "real" ||
+    t === "double" ||
+    t === "double precision" ||
+    t === "float" ||
+    t === "float4" ||
+    t === "float8" ||
+    t === "numeric" ||
+    t === "decimal" ||
+    t === "money" ||
+    t === "smallmoney"
+  )
+    return Schema.Number
+  if (
+    t === "text" ||
+    t === "varchar" ||
+    t === "char" ||
+    t === "nchar" ||
+    t === "nvarchar" ||
+    t === "ntext" ||
+    t === "character varying" ||
+    t === "character" ||
+    t === "bpchar" ||
+    t === "uuid" ||
+    t === "citext" ||
+    t === "name" ||
+    t === "xml"
+  )
+    return Schema.String
+  if (t === "boolean" || t === "bool" || t === "bit")
+    return Schema.Union(Schema.Boolean, Schema.Number)
+  if (
+    t === "timestamp" ||
+    t === "timestamptz" ||
+    t === "timestamp with time zone" ||
+    t === "timestamp without time zone" ||
+    t === "date" ||
+    t === "datetime" ||
+    t === "datetime2" ||
+    t === "smalldatetime" ||
+    t === "datetimeoffset" ||
+    t === "time"
+  )
+    return Schema.String
+  if (t === "json" || t === "jsonb") return Schema.Unknown
+  if (t === "blob" || t === "bytea" || t === "varbinary" || t === "binary" || t === "image")
+    return null
+  return null
+}
+
 const columnToSchema = (col) => {
-    const base = dataTypeToSchema(col.dataType);
-    if (base === null)
-        return null;
-    if (col.isNullable)
-        return Schema.NullOr(base);
-    return base;
-};
+  const base = dataTypeToSchema(col.dataType)
+  if (base === null) return null
+  if (col.isNullable) return Schema.NullOr(base)
+  return base
+}
+
 export const tableToSchema = (table) => {
-    const fields = {};
-    let hasFields = false;
-    for (const col of table.columns) {
-        const s = columnToSchema(col);
-        if (s === null)
-            continue;
-        fields[col.columnName] = s;
-        hasFields = true;
+  const fields = {}
+  let hasFields = false
+  for (const col of table.columns) {
+    const s = columnToSchema(col)
+    if (s === null) continue
+    fields[col.columnName] = s
+    hasFields = true
+  }
+  if (!hasFields) return null
+  return {
+    tableName: table.tableName,
+    tableSchema: table.tableSchema,
+    schema: Schema.Struct(fields),
+    columns: table.columns.filter((c) => columnToSchema(c) !== null),
+  }
+}
+
+export const toSchemas = (db) =>
+  db.tables.flatMap((t) => {
+    const s = tableToSchema(t)
+    return s ? [s] : []
+  })
+
+const escapeIdentifier = (id) => `"${id.replace(/"/g, '""')}"`
+
+const concatSql = (
+  sql,
+  fragments,
+) => {
+  const strings = []
+  const values = []
+  for (let i = 0; i < fragments.length; i++) {
+    const frag = fragments[i]
+    for (let j = 0; j < frag.strings.length; j++) {
+      if (j === 0 && strings.length > 0) {
+        strings[strings.length - 1] += frag.strings[j]
+      } else {
+        strings.push(frag.strings[j])
+      }
+      if (j < frag.values.length) values.push(frag.values[j])
     }
-    if (!hasFields)
-        return null;
-    return {
-        tableName: table.tableName,
-        tableSchema: table.tableSchema,
-        schema: Schema.Struct(fields),
-        columns: table.columns.filter((c) => columnToSchema(c) !== null),
-    };
-};
-export const toSchemas = (db) => db.tables.flatMap((t) => {
-    const s = tableToSchema(t);
-    return s ? [s] : [];
-});
-const escapeIdentifier = (id) => `"${id.replace(/"/g, '""')}"`;
-const buildWhereClause = (filters, columnSet, paramOffset) => {
-    const conditions = [];
-    const values = [];
-    for (const f of filters) {
-        if (!columnSet.has(f.column))
-            continue;
-        const col = escapeIdentifier(f.column);
-        const paramIndex = paramOffset + values.length + 1;
-        if (f.value === null) {
-            conditions.push(f.op === "eq" ? `${col} IS NULL` : `${col} IS NOT NULL`);
-        }
-        else {
-            conditions.push(`${col} ${f.op === "eq" ? "=" : "!="} $${paramIndex}`);
-            values.push(f.value);
-        }
+  }
+  const tsa = Object.assign([...strings], { raw: strings })
+  return sql(tsa, ...values)
+}
+
+const literal = (text) => ({ strings: [text], values: [] })
+
+const param = (value) => ({ strings: ["", ""], values: [value] })
+
+const buildWhereFragments = (
+  filters,
+  columnSet,
+) => {
+  const parts = []
+  const valid = filters.filter((f) => columnSet.has(f.column))
+  if (valid.length === 0) return parts
+  parts.push(literal(" WHERE "))
+  for (let i = 0; i < valid.length; i++) {
+    if (i > 0) parts.push(literal(" AND "))
+    const f = valid[i]
+    const col = escapeIdentifier(f.column)
+    if (f.value === null) {
+      parts.push(literal(f.op === "eq" ? `${col} IS NULL` : `${col} IS NOT NULL`))
+    } else {
+      parts.push(literal(`${col} ${f.op === "eq" ? "=" : "!="} `))
+      parts.push(param(f.value))
     }
-    return {
-        clause: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
-        values,
-    };
-};
+  }
+  return parts
+}
+
 const makeTableReader = (ts) => {
-    const qualifiedName = ts.tableSchema
-        ? `${escapeIdentifier(ts.tableSchema)}.${escapeIdentifier(ts.tableName)}`
-        : escapeIdentifier(ts.tableName);
-    const primaryKey = ts.columns.find((c) => c.isPrimaryKey);
-    const selectCols = ts.columns.map((c) => escapeIdentifier(c.columnName)).join(", ");
-    const columnSet = new Set(ts.columns.map((c) => c.columnName));
-    const sortableSet = new Set(ts.columns.filter((c) => c.isSortable).map((c) => c.columnName));
-    return {
-        tableName: ts.tableName,
-        tableSchema: ts.tableSchema,
-        schema: ts.schema,
-        columns: ts.columns,
-        sortableColumns: Array.from(sortableSet),
-        findAll: (options) => Effect.gen(function* () {
-            const sql = yield* Sql.SqlClient;
-            let query = `SELECT ${selectCols} FROM ${qualifiedName}`;
-            const where = options?.filters
-                ? buildWhereClause(options.filters, columnSet, 0)
-                : { clause: "", values: [] };
-            query += where.clause;
-            if (options?.sort && options.sort.length > 0) {
-                const sortClauses = options.sort
-                    .filter((s) => sortableSet.has(s.column))
-                    .map((s) => `${escapeIdentifier(s.column)} ${s.reverse ? "DESC" : "ASC"}`);
-                if (sortClauses.length > 0)
-                    query += ` ORDER BY ${sortClauses.join(", ")}`;
-            }
-            if (options?.limit !== undefined)
-                query += ` LIMIT ${Number(options.limit)}`;
-            if (options?.offset !== undefined)
-                query += ` OFFSET ${Number(options.offset)}`;
-            return yield* sql.unsafe(query, where.values);
-        }),
-        findById: (id) => Effect.gen(function* () {
-            if (!primaryKey)
-                return null;
-            const sql = yield* Sql.SqlClient;
-            const query = `SELECT ${selectCols} FROM ${qualifiedName} WHERE ${escapeIdentifier(primaryKey.columnName)} = $1`;
-            const rows = yield* sql.unsafe(query, [id]);
-            return rows[0] ?? null;
-        }),
-        count: (options) => Effect.gen(function* () {
-            const sql = yield* Sql.SqlClient;
-            let query = `SELECT COUNT(*) as count FROM ${qualifiedName}`;
-            const where = options?.filters
-                ? buildWhereClause(options.filters, columnSet, 0)
-                : { clause: "", values: [] };
-            query += where.clause;
-            const rows = yield* sql.unsafe(query, where.values);
-            return Number(rows[0].count);
-        }),
-    };
-};
+  const qualifiedName = ts.tableSchema
+    ? `${escapeIdentifier(ts.tableSchema)}.${escapeIdentifier(ts.tableName)}`
+    : escapeIdentifier(ts.tableName)
+  const primaryKey = ts.columns.find((c) => c.isPrimaryKey)
+  const selectCols = ts.columns.map((c) => escapeIdentifier(c.columnName)).join(", ")
+  const columnSet = new Set(ts.columns.map((c) => c.columnName))
+  const sortableSet = new Set(ts.columns.filter((c) => c.isSortable).map((c) => c.columnName))
+
+  return {
+    tableName: ts.tableName,
+    tableSchema: ts.tableSchema,
+    schema: ts.schema,
+    columns: ts.columns,
+    sortableColumns: Array.from(sortableSet),
+    findAll: (options) =>
+      Effect.gen(function* () {
+        const sql = yield* Sql.SqlClient
+        const fragments = [
+          literal(`SELECT ${selectCols} FROM ${qualifiedName}`),
+        ]
+        if (options?.filters) {
+          fragments.push(...buildWhereFragments(options.filters, columnSet))
+        }
+        if (options?.sort && options.sort.length > 0) {
+          const sortClauses = options.sort
+            .filter((s) => sortableSet.has(s.column))
+            .map((s) => `${escapeIdentifier(s.column)} ${s.reverse ? "DESC" : "ASC"}`)
+          if (sortClauses.length > 0) fragments.push(literal(` ORDER BY ${sortClauses.join(", ")}`))
+        }
+        if (options?.limit !== undefined)
+          fragments.push(literal(` LIMIT ${Math.trunc(Number(options.limit))}`))
+        if (options?.offset !== undefined)
+          fragments.push(literal(` OFFSET ${Math.trunc(Number(options.offset))}`))
+        return yield* concatSql(sql, fragments)
+      }),
+    findById: (id) =>
+      Effect.gen(function* () {
+        if (!primaryKey) return null
+        const sql = yield* Sql.SqlClient
+        const pkCol = escapeIdentifier(primaryKey.columnName)
+        const rows = yield* concatSql(sql, [
+          literal(`SELECT ${selectCols} FROM ${qualifiedName} WHERE ${pkCol} = `),
+          param(id),
+        ])
+        return rows[0] ?? null
+      }),
+    count: (options) =>
+      Effect.gen(function* () {
+        const sql = yield* Sql.SqlClient
+        const fragments = [
+          literal(`SELECT COUNT(*) as count FROM ${qualifiedName}`),
+        ]
+        if (options?.filters) {
+          fragments.push(...buildWhereFragments(options.filters, columnSet))
+        }
+        const rows = yield* concatSql(sql, fragments)
+        return Number((rows[0]).count)
+      }),
+  }
+}
+
 export const makeDatabaseReader = (db) => {
-    const schemas = toSchemas(db);
-    const readers = schemas.map(makeTableReader);
-    return {
-        tables: readers,
-        table: (name) => readers.find((r) => r.tableName === name),
-    };
-};
+  const schemas = toSchemas(db)
+  const readers = schemas.map(makeTableReader)
+  return {
+    tables: readers,
+    table: (name) => readers.find((r) => r.tableName === name),
+  }
+}