@getstrata/core 2.0.6 → 2.0.8

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @getstrata/core changelog
 
+## 2.0.8
+
+- fix(schema): preserve constraints and generate builder migrations
+
+## 2.0.7
+
+- Fix concurrent Postgres role provisioning across databases
+
 ## 2.0.6
 
 - Dispatch registered Bun route preflights through CORS

package/dist/core/database/schema/blueprint.d.ts

@@ -7,12 +7,25 @@ interface IndexDefinition {
     where?: string;
     order?: "asc" | "desc";
 }
+interface TableForeignKeyDefinition {
+    columns: string[];
+    referencesTable: string;
+    referencesColumns: string[];
+    name?: string;
+    onDelete?: "cascade" | "set null" | "restrict";
+}
+interface TableCheckDefinition {
+    expression: string;
+    name?: string;
+}
 type BlueprintAction = "create" | "alter" | "drop";
 declare class Blueprint {
     readonly table: string;
     readonly action: BlueprintAction;
     readonly columns: ColumnDefinition[];
     readonly indexes: IndexDefinition[];
+    readonly foreignKeys: TableForeignKeyDefinition[];
+    readonly checks: TableCheckDefinition[];
     readonly droppedColumns: string[];
     readonly droppedIndexes: string[];
     constructor(table: string, action: BlueprintAction);
@@ -32,6 +45,11 @@ declare class Blueprint {
     dropSoftDeletes(): void;
     dropIndex(name: string): void;
     unique(columns: string | string[], name?: string): void;
+    foreignKey(columns: string[], referencesTable: string, referencesColumns: string[], options?: {
+        name?: string;
+        onDelete?: "cascade" | "set null" | "restrict";
+    }): void;
+    check(expression: string, name?: string): void;
     index(columns: string | string[], options?: {
         name?: string;
         order?: "asc" | "desc";
@@ -43,5 +61,5 @@ declare class Blueprint {
     fullText(columns: string | string[], name?: string): void;
     ginIndex(column: string, name?: string): void;
 }
-export type { BlueprintAction, IndexDefinition, IndexKind };
+export type { BlueprintAction, IndexDefinition, IndexKind, TableCheckDefinition, TableForeignKeyDefinition, };
 export { Blueprint };

package/dist/core/database/schema/grammars/compileStatements.d.ts

@@ -3,6 +3,6 @@ import type { ColumnDefinition } from "../columnDefinition.ts";
 import type { DatabaseDriver } from "../driver.ts";
 declare function compileDropTable(driver: DatabaseDriver, tableName: string): string[];
 declare function compileColumn(driver: DatabaseDriver, column: ColumnDefinition, mode: "create" | "alter"): string;
-declare function compileIndex(_driver: DatabaseDriver, tableName: string, index: IndexDefinition): string;
+declare function compileIndex(driver: DatabaseDriver, tableName: string, index: IndexDefinition): string;
 declare function compileBlueprint(driver: DatabaseDriver, blueprint: Blueprint): string[];
 export { compileBlueprint, compileColumn, compileDropTable, compileIndex };

package/dist/core/database/schema/index.d.ts

@@ -1,4 +1,4 @@
-export type { BlueprintAction, IndexDefinition, IndexKind } from "./blueprint.ts";
+export type { BlueprintAction, IndexDefinition, IndexKind, TableCheckDefinition, TableForeignKeyDefinition, } from "./blueprint.ts";
 export { Blueprint } from "./blueprint.ts";
 export type { ColumnKind, ForeignKeyOptions } from "./columnDefinition.ts";
 export { ColumnDefinition, ForeignIdColumnDefinition, inferReferencedTable, } from "./columnDefinition.ts";

package/dist/entries/database/schema.js

@@ -52,6 +52,181 @@ function resolveDatabaseDriver(options = {}) {
 }
 var init_driver = () => {};
 
+// ../../src/core/runtime/asyncContextStore.ts
+import { AsyncLocalStorage } from "async_hooks";
+function createAsyncContextStore(key) {
+  const symbol = Symbol.for(key);
+  const globalRecord = globalThis;
+  const existing = globalRecord[symbol];
+  if (existing) {
+    return existing;
+  }
+  const store = new AsyncLocalStorage;
+  globalRecord[symbol] = store;
+  return store;
+}
+var init_asyncContextStore = () => {};
+
+// ../../src/core/database/dialect.ts
+function assertSafeIdentifier(identifier) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
+  }
+  return identifier;
+}
+function quoteIdentifierFor(dialect, column) {
+  return dialect.quoteIdentifier(column);
+}
+function dialectFor(driver) {
+  return dialects[driver];
+}
+function currentSqlDialect() {
+  return dialectContext.getStore() ?? dialectOverride ?? dialectFor(resolveDatabaseDriver());
+}
+var postgresDialect, mysqlDialect, sqliteDialect, dialects, dialectContext, dialectOverride = null;
+var init_dialect = __esm(() => {
+  init_asyncContextStore();
+  init_driver();
+  postgresDialect = {
+    driver: "pgsql",
+    placeholder(index) {
+      return `$${index}`;
+    },
+    quoteIdentifier(identifier) {
+      return `"${assertSafeIdentifier(identifier)}"`;
+    },
+    nowExpression() {
+      return "NOW()";
+    },
+    epochMillisecondsExpression() {
+      return "CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
+    timestampValue(value) {
+      return value.toISOString();
+    },
+    returningClause(columns) {
+      return ` RETURNING ${columns}`;
+    },
+    ilikeOperator() {
+      return "ILIKE";
+    },
+    nullsLastSuffix() {
+      return " NULLS LAST";
+    },
+    castToText(expression) {
+      return `${expression}::text`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+      if (updateColumns.length === 0) {
+        return ` ON CONFLICT (${target}) DO NOTHING`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = excluded.${quoted}`;
+      }).join(", ");
+      return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+    }
+  };
+  mysqlDialect = {
+    driver: "mysql",
+    placeholder() {
+      return "?";
+    },
+    quoteIdentifier(identifier) {
+      return `\`${assertSafeIdentifier(identifier)}\``;
+    },
+    nowExpression() {
+      return "CURRENT_TIMESTAMP";
+    },
+    epochMillisecondsExpression() {
+      return "CAST(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000 AS UNSIGNED)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
+    timestampValue(value) {
+      return value.toISOString().slice(0, 19).replace("T", " ");
+    },
+    returningClause() {
+      return "";
+    },
+    ilikeOperator() {
+      return "LIKE";
+    },
+    nullsLastSuffix() {
+      return "";
+    },
+    castToText(expression) {
+      return `CAST(${expression} AS CHAR)`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      if (updateColumns.length === 0) {
+        const anchor = quoteIdentifierFor(this, conflictColumns[0] ?? "");
+        return ` ON DUPLICATE KEY UPDATE ${anchor} = ${anchor}`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = VALUES(${quoted})`;
+      }).join(", ");
+      return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+    }
+  };
+  sqliteDialect = {
+    driver: "sqlite",
+    placeholder() {
+      return "?";
+    },
+    quoteIdentifier(identifier) {
+      return `"${assertSafeIdentifier(identifier)}"`;
+    },
+    nowExpression() {
+      return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
+    },
+    epochMillisecondsExpression() {
+      return "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+    },
+    rowLockClause() {
+      return "";
+    },
+    timestampValue(value) {
+      return value.toISOString();
+    },
+    returningClause(columns) {
+      return ` RETURNING ${columns}`;
+    },
+    ilikeOperator() {
+      return "LIKE";
+    },
+    nullsLastSuffix() {
+      return "";
+    },
+    castToText(expression) {
+      return `CAST(${expression} AS TEXT)`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+      if (updateColumns.length === 0) {
+        return ` ON CONFLICT (${target}) DO NOTHING`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = excluded.${quoted}`;
+      }).join(", ");
+      return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+    }
+  };
+  dialects = {
+    pgsql: postgresDialect,
+    mysql: mysqlDialect,
+    sqlite: sqliteDialect
+  };
+  dialectContext = createAsyncContextStore("@getstrata/sqlDialect");
+});
+
 // ../../src/core/database/schema/columnDefinition.ts
 class ColumnDefinition {
   name;
@@ -150,6 +325,8 @@ class Blueprint {
   action;
   columns = [];
   indexes = [];
+  foreignKeys = [];
+  checks = [];
   droppedColumns = [];
   droppedIndexes = [];
   constructor(table, action) {
@@ -164,6 +341,9 @@ class Blueprint {
     return column;
   }
   string(name, length) {
+    if (length !== undefined && (!Number.isSafeInteger(length) || length <= 0)) {
+      throw new Error("String length must be a positive safe integer.");
+    }
     const column = new ColumnDefinition(name, "string");
     column.length = length;
     column.notNullable();
@@ -241,6 +421,22 @@ class Blueprint {
       kind: "unique"
     });
   }
+  foreignKey(columns, referencesTable, referencesColumns, options = {}) {
+    if (!columns.length || columns.length !== referencesColumns.length) {
+      throw new Error("Foreign key columns must be nonempty and match referenced columns.");
+    }
+    this.foreignKeys.push({
+      columns: [...columns],
+      referencesTable,
+      referencesColumns: [...referencesColumns],
+      ...options
+    });
+  }
+  check(expression, name) {
+    if (!expression.trim())
+      throw new Error("Check expression must not be empty.");
+    this.checks.push({ expression, name });
+  }
   index(columns, options = {}) {
     this.indexes.push({
       name: options.name,
@@ -284,518 +480,8 @@ class UnsupportedSchemaFeatureError extends Error {
     this.name = "UnsupportedSchemaFeatureError";
   }
 }
-// ../../src/core/database/query.ts
-import { currentSqlDialect } from "@getstrata/core/database/dialect";
-function quoteIdentifier(identifier) {
-  return currentSqlDialect().quoteIdentifier(identifier);
-}
-function returningSuffix(columns) {
-  return currentSqlDialect().returningClause(columns);
-}
-function qualifyColumn(tableName, column) {
-  return `${quoteIdentifier(tableName)}.${quoteIdentifier(column)}`;
-}
-function resolveQualifiedColumn(defaultTable, columnName) {
-  if (columnName.includes(".")) {
-    const [table, column] = columnName.split(".", 2);
-    if (!table || !column) {
-      throw new Error(`Invalid qualified column: ${columnName}`);
-    }
-    return qualifyColumn(table, column);
-  }
-  return qualifyColumn(defaultTable, columnName);
-}
-function parseQualifiedColumn(reference) {
-  const [table, column] = reference.split(".", 2);
-  if (!table || !column) {
-    throw new Error(`Join columns must be qualified as table.column: ${reference}`);
-  }
-  return { table, column };
-}
-function normalizeDirection(direction = "ASC") {
-  return direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
-}
-function isQueryOperator(value) {
-  return value !== null && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object";
-}
-function pushParam(values, value) {
-  values.push(value);
-  return currentSqlDialect().placeholder(values.length);
-}
-var SUPPORTED_OPERATORS = new Set([
-  "eq",
-  "ne",
-  "in",
-  "notIn",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "isNull",
-  "ilike",
-  "tsMatch"
-]);
-function buildInClause(column, values, params, negated = false) {
-  if (values.length === 0) {
-    return negated ? "1 = 1" : "1 = 0";
-  }
-  const placeholders = values.map((value) => pushParam(params, value)).join(", ");
-  return `${column}${negated ? " NOT" : ""} IN (${placeholders})`;
-}
-function buildOperatorClauses(column, operator, params) {
-  const clauses = [];
-  const unsupported = Object.keys(operator).filter((key) => !SUPPORTED_OPERATORS.has(key));
-  if (unsupported.length > 0) {
-    throw new Error(`Unsupported query operator(s) for ${column}: ${unsupported.join(", ")}. Supported: ${[...SUPPORTED_OPERATORS].join(", ")}.`);
-  }
-  if (operator.isNull === true) {
-    clauses.push(`${column} IS NULL`);
-  }
-  if (operator.isNull === false) {
-    clauses.push(`${column} IS NOT NULL`);
-  }
-  if (operator.eq !== undefined) {
-    if (operator.eq === null) {
-      clauses.push(`${column} IS NULL`);
-    } else {
-      clauses.push(`${column} = ${pushParam(params, operator.eq)}`);
-    }
-  }
-  if (operator.ne !== undefined) {
-    if (operator.ne === null) {
-      clauses.push(`${column} IS NOT NULL`);
-    } else {
-      clauses.push(`${column} <> ${pushParam(params, operator.ne)}`);
-    }
-  }
-  if (operator.in !== undefined) {
-    clauses.push(buildInClause(column, operator.in, params));
-  }
-  if (operator.notIn !== undefined) {
-    clauses.push(buildInClause(column, operator.notIn, params, true));
-  }
-  if (operator.gt !== undefined) {
-    clauses.push(`${column} > ${pushParam(params, operator.gt)}`);
-  }
-  if (operator.gte !== undefined) {
-    clauses.push(`${column} >= ${pushParam(params, operator.gte)}`);
-  }
-  if (operator.lt !== undefined) {
-    clauses.push(`${column} < ${pushParam(params, operator.lt)}`);
-  }
-  if (operator.lte !== undefined) {
-    clauses.push(`${column} <= ${pushParam(params, operator.lte)}`);
-  }
-  if (operator.ilike !== undefined) {
-    clauses.push(`${column} ${currentSqlDialect().ilikeOperator()} ${pushParam(params, operator.ilike)}`);
-  }
-  if (operator.tsMatch !== undefined) {
-    if (currentSqlDialect().driver !== "pgsql") {
-      throw new Error("Full-text search (tsMatch) is only available on PostgreSQL.");
-    }
-    clauses.push(`${column} @@ plainto_tsquery('english', ${pushParam(params, operator.tsMatch)})`);
-  }
-  return clauses;
-}
-function appendWhereParts(tableName, where, params) {
-  const clauses = [];
-  for (const [columnName, filterValue] of Object.entries(where)) {
-    if (filterValue === undefined) {
-      continue;
-    }
-    const column = resolveQualifiedColumn(tableName, columnName);
-    if (Array.isArray(filterValue)) {
-      clauses.push(buildInClause(column, filterValue, params));
-      continue;
-    }
-    if (isQueryOperator(filterValue)) {
-      clauses.push(...buildOperatorClauses(column, filterValue, params));
-      continue;
-    }
-    if (filterValue === null) {
-      clauses.push(`${column} IS NULL`);
-      continue;
-    }
-    clauses.push(`${column} = ${pushParam(params, filterValue)}`);
-  }
-  return clauses.join(" AND ");
-}
-function buildWhereClause(tableName, where = {}) {
-  const params = [];
-  const body = appendWhereParts(tableName, where, params);
-  return {
-    clause: body.length > 0 ? ` WHERE ${body}` : "",
-    params
-  };
-}
-function remapExistsSql(sql, existsParams, params) {
-  const offset = params.length;
-  params.push(...existsParams);
-  return sql.replace(/\$(\d+)/g, (_match, index) => `$${offset + Number(index)}`);
-}
-function buildWhereNodeClause(tableName, node, params) {
-  if ("exists" in node) {
-    const body = remapExistsSql(node.exists.sql, node.exists.params, params);
-    return `${node.exists.not ? "NOT " : ""}EXISTS (${body})`;
-  }
-  if ("where" in node) {
-    return appendWhereParts(tableName, node.where, params);
-  }
-  const grouped = buildWhereGroupClause(tableName, node.group, params);
-  if (!grouped) {
-    return "";
-  }
-  return grouped.includes(" OR ") ? `(${grouped})` : grouped;
-}
-function buildWhereGroupClause(tableName, nodes, params) {
-  let result = "";
-  for (const node of nodes) {
-    const part = buildWhereNodeClause(tableName, node, params);
-    if (!part) {
-      continue;
-    }
-    if (!result) {
-      result = part;
-      continue;
-    }
-    result = node.kind === "or" ? `${result} OR ${part}` : `${result} AND ${part}`;
-  }
-  if (!result) {
-    return "";
-  }
-  return result;
-}
-function buildAdvancedWhereClause(tableName, where = {}, whereNodes = [], params = []) {
-  const nodes = [];
-  if (Object.keys(where).length > 0) {
-    nodes.push({ kind: "and", where });
-  }
-  nodes.push(...whereNodes);
-  const combined = buildWhereGroupClause(tableName, nodes, params);
-  return {
-    clause: combined ? ` WHERE ${combined}` : "",
-    params
-  };
-}
-function resolveSoftDeleteColumn(table) {
-  if (!table.softDeletes) {
-    return null;
-  }
-  if (table.softDeletes === true) {
-    return "deleted_at";
-  }
-  return table.softDeletes.column ?? "deleted_at";
-}
-function appendSoftDeleteScope(table, options, clauses) {
-  const column = resolveSoftDeleteColumn(table);
-  if (!column) {
-    return;
-  }
-  const qualifiedColumn = qualifyColumn(table.name, column);
-  if (options.onlyTrashed) {
-    clauses.push(`${qualifiedColumn} IS NOT NULL`);
-    return;
-  }
-  if (!options.withTrashed) {
-    clauses.push(`${qualifiedColumn} IS NULL`);
-  }
-}
-function buildQueryWhereClause(table, options = {}, whereNodes = [], params = []) {
-  const { clause, params: whereParams } = buildAdvancedWhereClause(table.name, options.where ?? {}, whereNodes, params);
-  const softDeleteClauses = [];
-  appendSoftDeleteScope(table, options, softDeleteClauses);
-  if (softDeleteClauses.length === 0) {
-    return { clause, params: whereParams };
-  }
-  const base = clause.replace(/^ WHERE /, "");
-  const scope = softDeleteClauses.join(" AND ");
-  return {
-    clause: base ? ` WHERE (${base}) AND ${scope}` : ` WHERE ${scope}`,
-    params: whereParams
-  };
-}
-function isQueryOrder(value) {
-  return "column" in value;
-}
-function normalizeOrderBy(orderBy) {
-  if (!orderBy) {
-    return [];
-  }
-  if (Array.isArray(orderBy)) {
-    return orderBy;
-  }
-  if (isQueryOrder(orderBy)) {
-    return [orderBy];
-  }
-  return Object.entries(orderBy).map(([column, direction]) => ({
-    column,
-    direction
-  }));
-}
-function buildOrderByClause(tableName, orderBy) {
-  const parts = normalizeOrderBy(orderBy).map(({ column, direction }) => {
-    return `${resolveQualifiedColumn(tableName, column)} ${normalizeDirection(direction)}`;
-  });
-  return parts.length > 0 ? ` ORDER BY ${parts.join(", ")}` : "";
-}
-function buildGroupByClause(tableName, groupBy) {
-  if (!groupBy) {
-    return "";
-  }
-  const columns = (Array.isArray(groupBy) ? groupBy : [groupBy]).map((column) => String(column));
-  const parts = columns.map((column) => resolveQualifiedColumn(tableName, column));
-  return parts.length > 0 ? ` GROUP BY ${parts.join(", ")}` : "";
-}
-function buildHavingClause(tableName, having, params) {
-  if (!having) {
-    return "";
-  }
-  const body = appendWhereParts(tableName, having, params);
-  return body.length > 0 ? ` HAVING ${body}` : "";
-}
-function buildJoinClause(joins = []) {
-  return joins.map((join) => {
-    const joinType = join.type === "left" ? "LEFT JOIN" : "INNER JOIN";
-    const onClause = join.on.map(({ left, right }) => `${qualifyColumn(left.table, left.column)} = ${qualifyColumn(right.table, right.column)}`).join(" AND ");
-    return ` ${joinType} ${quoteIdentifier(join.table)} ON ${onClause}`;
-  }).join("");
-}
-function buildLimitClause(limit) {
-  if (limit === undefined) {
-    return "";
-  }
-  if (!Number.isInteger(limit) || limit <= 0) {
-    throw new Error("Query limit must be a positive integer.");
-  }
-  return ` LIMIT ${limit}`;
-}
-function buildOffsetClause(offset) {
-  if (offset === undefined) {
-    return "";
-  }
-  if (!Number.isInteger(offset) || offset < 0) {
-    throw new Error("Query offset must be a non-negative integer.");
-  }
-  return ` OFFSET ${offset}`;
-}
-function buildReturningColumns(table) {
-  return table.columns.map((column) => qualifyColumn(table.name, column)).join(", ");
-}
-function buildSelectList(table, select, params = []) {
-  if (!select || select.length === 0) {
-    return buildReturningColumns(table);
-  }
-  return select.map((item) => {
-    if (item.kind === "column") {
-      const column = qualifyColumn(item.table, item.column);
-      return item.as ? `${column} AS ${quoteIdentifier(item.as)}` : column;
-    }
-    if (item.kind === "literalText") {
-      return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
-    }
-    if (item.kind === "subqueryCount") {
-      const body = remapExistsSql(item.sql, item.params, params);
-      return `(${body}) AS ${quoteIdentifier(item.as)}`;
-    }
-    const column = qualifyColumn(item.table, item.column);
-    const placeholder = pushParam(params, item.query);
-    return `ts_rank(${column}, plainto_tsquery('english', ${placeholder})) AS ${quoteIdentifier(item.as)}`;
-  }).join(", ");
-}
-function getDefinedColumnEntries(table, values, options = {}) {
-  const record = values;
-  const excluded = new Set(options.exclude ?? []);
-  return table.columns.flatMap((column) => {
-    if (excluded.has(column) || !Object.hasOwn(record, column)) {
-      return [];
-    }
-    const value = record[column];
-    if (value === undefined) {
-      return [];
-    }
-    return [[column, value]];
-  });
-}
-function buildSelectQuery(table, options = {}, whereNodes = []) {
-  const params = [];
-  const columns = buildSelectList(table, options.select, params);
-  const { clause } = buildQueryWhereClause(table, options, whereNodes, params);
-  const joins = buildJoinClause(options.joins);
-  const groupBy = buildGroupByClause(table.name, options.groupBy);
-  const havingClause = buildHavingClause(table.name, options.having, params);
-  const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
-  const limit = buildLimitClause(options.limit);
-  const offset = buildOffsetClause(options.offset);
-  return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
-    params
-  };
-}
-function buildCountQuery(table, where = {}, options = {}, whereNodes = []) {
-  const params = [];
-  const { clause, params: whereParams } = buildQueryWhereClause(table, {
-    where,
-    withTrashed: options.withTrashed,
-    onlyTrashed: options.onlyTrashed
-  }, whereNodes);
-  params.push(...whereParams);
-  const joins = buildJoinClause(options.joins);
-  const groupBy = buildGroupByClause(table.name, options.groupBy);
-  return {
-    text: `SELECT COUNT(*) AS count FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}`,
-    params
-  };
-}
-function buildProjectionQuery(table, expression, alias, options = {}, whereNodes = []) {
-  assertSafeProjectionExpression(expression);
-  const params = [];
-  const { clause, params: whereParams } = buildQueryWhereClause(table, options, whereNodes);
-  params.push(...whereParams);
-  const joins = buildJoinClause(options.joins);
-  const groupBy = buildGroupByClause(table.name, options.groupBy);
-  const orderBy = buildOrderByClause(table.name, options.orderBy);
-  const limit = buildLimitClause(options.limit);
-  return {
-    text: `SELECT ${expression} AS ${quoteIdentifier(alias)} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${orderBy}${limit}`,
-    params
-  };
-}
-var SAFE_PROJECTION_EXPRESSION = /^(COUNT\(\*\)|(?:"[\w_]+"(?:\."[\w_]+")?)|(?:AVG|SUM|MIN|MAX)\((?:"[\w_]+"(?:\."[\w_]+")?)\))$/;
-function assertSafeProjectionExpression(expression) {
-  if (!SAFE_PROJECTION_EXPRESSION.test(expression.trim())) {
-    throw new Error(`Unsafe projection expression: ${expression}`);
-  }
-}
-function buildGroupedCountQuery(table, column, where = {}, options = {}) {
-  const qualifiedColumn = qualifyColumn(table.name, column);
-  const { clause, params } = buildQueryWhereClause(table, {
-    where,
-    ...options
-  });
-  return {
-    text: `SELECT ${qualifiedColumn} AS ${quoteIdentifier("value")}, COUNT(*) AS ${quoteIdentifier("count")} FROM ${quoteIdentifier(table.name)}${clause} GROUP BY ${qualifiedColumn} ORDER BY ${qualifiedColumn} ASC`,
-    params
-  };
-}
-function buildInsertQuery(table, values) {
-  const entries = getDefinedColumnEntries(table, values);
-  if (entries.length === 0) {
-    throw new Error(`Cannot insert into ${table.name} without any column values.`);
-  }
-  const params = [];
-  const columns = entries.map(([column]) => quoteIdentifier(column)).join(", ");
-  const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
-  const returningColumns = buildReturningColumns(table);
-  return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildUpsertQuery(table, values, conflictColumns, updateColumns) {
-  const entries = getDefinedColumnEntries(table, values);
-  if (entries.length === 0) {
-    throw new Error(`Cannot upsert into ${table.name} without any column values.`);
-  }
-  if (conflictColumns.length === 0) {
-    throw new Error(`Cannot upsert into ${table.name} without any conflict columns.`);
-  }
-  const insertable = new Set(entries.map(([column]) => column));
-  const conflict = new Set(conflictColumns);
-  const updatable = (updateColumns ?? entries.map(([column]) => column).filter((c) => !conflict.has(c))).filter((column) => insertable.has(column));
-  const params = [];
-  const columns = entries.map(([column]) => quoteIdentifier(column)).join(", ");
-  const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
-  const returningColumns = buildReturningColumns(table);
-  const suffix = currentSqlDialect().upsertSuffix(conflictColumns, updatable);
-  return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${suffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildIncrementQuery(table, id, column, amount, extra = {}) {
-  if (!Number.isFinite(amount)) {
-    throw new Error("Increment amount must be a finite number.");
-  }
-  if (!table.columns.includes(column)) {
-    throw new Error(`Unknown column ${String(column)} on ${table.name}.`);
-  }
-  const params = [];
-  const target = quoteIdentifier(column);
-  const assignments = [`${target} = ${target} + ${pushParam(params, amount)}`];
-  for (const [name, value] of getDefinedColumnEntries(table, extra, {
-    exclude: [table.primaryKey, column]
-  })) {
-    assignments.push(`${quoteIdentifier(name)} = ${pushParam(params, value)}`);
-  }
-  const primaryKeyPlaceholder = pushParam(params, id);
-  const returningColumns = buildReturningColumns(table);
-  const scopeClauses = [];
-  appendSoftDeleteScope(table, {}, scopeClauses);
-  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildUpdateQuery(table, id, changes) {
-  const entries = getDefinedColumnEntries(table, changes, {
-    exclude: [table.primaryKey]
-  });
-  if (entries.length === 0) {
-    throw new Error(`Cannot update ${table.name} without any changed column values.`);
-  }
-  const params = [];
-  const setClause = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`).join(", ");
-  const primaryKeyPlaceholder = pushParam(params, id);
-  const returningColumns = buildReturningColumns(table);
-  const scopeClauses = [];
-  appendSoftDeleteScope(table, {}, scopeClauses);
-  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${setClause} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildSoftDeleteByIdQuery(table, id, deletedAt) {
-  const deletedAtColumn = resolveSoftDeleteColumn(table);
-  if (!deletedAtColumn) {
-    throw new Error(`Table ${table.name} does not support soft deletes.`);
-  }
-  const returningColumns = buildReturningColumns(table);
-  const scopeClauses = [];
-  appendSoftDeleteScope(table, {}, scopeClauses);
-  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
-  const params = [];
-  const deletedAtPlaceholder = pushParam(params, deletedAt);
-  const idPlaceholder = pushParam(params, id);
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildRestoreByIdQuery(table, id) {
-  const deletedAtColumn = resolveSoftDeleteColumn(table);
-  if (!deletedAtColumn) {
-    throw new Error(`Table ${table.name} does not support soft deletes.`);
-  }
-  const returningColumns = buildReturningColumns(table);
-  const params = [];
-  const deletedAtPlaceholder = pushParam(params, null);
-  const idPlaceholder = pushParam(params, id);
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder} AND ${qualifyColumn(table.name, deletedAtColumn)} IS NOT NULL${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildDeleteByIdQuery(table, id) {
-  const params = [];
-  const idPlaceholder = pushParam(params, id);
-  const returning = returningSuffix(`${quoteIdentifier(table.primaryKey)} AS ${quoteIdentifier("deleted_id")}`);
-  return {
-    text: `DELETE FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${returning}`,
-    params
-  };
-}
+// ../../src/core/database/schema/grammars/compileStatements.ts
+init_dialect();
 
 // ../../src/core/database/schema/grammars/grammar.ts
 function compileColumnType(driver, column) {
@@ -836,7 +522,7 @@ function compileIdType(driver) {
 function compileStringType(driver, length) {
   switch (driver) {
     case "pgsql":
-      return "TEXT";
+      return length ? `VARCHAR(${length})` : "TEXT";
     case "mysql":
       return length ? `VARCHAR(${length})` : "VARCHAR(255)";
     case "sqlite":
@@ -914,15 +600,30 @@ function compileJsonbType(driver) {
 }
 
 // ../../src/core/database/schema/grammars/compileStatements.ts
+function compileTableConstraints(driver, blueprint) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
+  const named = (name) => name ? `CONSTRAINT ${quoteIdentifier(name)} ` : "";
+  const columns = (names) => names.map(quoteIdentifier).join(", ");
+  return [
+    ...blueprint.foreignKeys.map((key) => {
+      const deletion = key.onDelete ? ` ON DELETE ${key.onDelete.toUpperCase()}` : "";
+      return `${named(key.name)}FOREIGN KEY (${columns(key.columns)}) REFERENCES ${quoteIdentifier(key.referencesTable)}(${columns(key.referencesColumns)})${deletion}`;
+    }),
+    ...blueprint.checks.map((check) => `${named(check.name)}CHECK (${check.expression})`)
+  ];
+}
 function compileCreateTable(driver, blueprint) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const table = quoteIdentifier(blueprint.table);
   const parts = blueprint.columns.map((column) => compileColumn(driver, column, "create"));
   for (const index of blueprint.indexes) {
-    if (index.kind === "unique" && index.columns.length > 1) {
+    if (index.kind === "unique") {
       const columns = index.columns.map((column) => quoteIdentifier(column)).join(", ");
-      parts.push(`UNIQUE (${columns})`);
+      const name = index.name ? `CONSTRAINT ${quoteIdentifier(index.name)} ` : "";
+      parts.push(`${name}UNIQUE (${columns})`);
     }
   }
+  parts.push(...compileTableConstraints(driver, blueprint));
   const statements = [`CREATE TABLE IF NOT EXISTS ${table} (
   ${parts.join(`,
   `)}
@@ -940,6 +641,7 @@ function compileCreateTable(driver, blueprint) {
   return statements;
 }
 function compileAlterTable(driver, blueprint) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const statements = [];
   const table = quoteIdentifier(blueprint.table);
   for (const column of blueprint.columns) {
@@ -947,12 +649,20 @@ function compileAlterTable(driver, blueprint) {
     statements.push(`ALTER TABLE ${table}
 ${addPrefix} ${compileColumn(driver, column, "alter")}`);
   }
+  if (blueprint.foreignKeys.length || blueprint.checks.length) {
+    if (driver === "sqlite") {
+      throw new UnsupportedSchemaFeatureError("adding table constraints; rebuild the SQLite table", driver);
+    }
+    for (const constraint of compileTableConstraints(driver, blueprint)) {
+      statements.push(`ALTER TABLE ${table} ADD ${constraint}`);
+    }
+  }
   for (const columnName of blueprint.droppedColumns) {
     const dropPrefix = driver === "pgsql" ? "DROP COLUMN IF EXISTS" : "DROP COLUMN";
     statements.push(`ALTER TABLE ${table} ${dropPrefix} ${quoteIdentifier(columnName)}`);
   }
   for (const indexName of blueprint.droppedIndexes) {
-    statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`);
+    statements.push(driver === "mysql" ? `DROP INDEX ${quoteIdentifier(indexName)} ON ${table}` : `DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`);
   }
   for (const index of blueprint.indexes) {
     if (index.kind === "index" || index.kind === "unique") {
@@ -964,10 +674,12 @@ ${addPrefix} ${compileColumn(driver, column, "alter")}`);
   return statements;
 }
 function compileDropTable(driver, tableName) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const cascade = driver === "pgsql" ? " CASCADE" : "";
   return [`DROP TABLE IF EXISTS ${quoteIdentifier(tableName)}${cascade}`];
 }
 function compileColumn(driver, column, mode) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const parts = [quoteIdentifier(column.name), compileColumnType(driver, column)];
   if (column.autoIncrement && driver === "mysql") {
     parts[1] = `${parts[1]} AUTO_INCREMENT`;
@@ -1005,7 +717,8 @@ function compileColumn(driver, column, mode) {
   }
   return parts.join(" ");
 }
-function compileIndex(_driver, tableName, index) {
+function compileIndex(driver, tableName, index) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const indexName = index.name ?? defaultIndexName(tableName, index.columns, index.kind === "unique" ? "unique" : "index");
   const columns = index.columns.map((column) => {
     const quoted = quoteIdentifier(column);
@@ -1015,9 +728,11 @@ function compileIndex(_driver, tableName, index) {
     return quoted;
   }).join(", ");
   const unique = index.kind === "unique" ? "UNIQUE " : "";
-  return `CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)}(${columns})`;
+  const existence = driver === "mysql" ? "" : "IF NOT EXISTS ";
+  return `CREATE ${unique}INDEX ${existence}${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)}(${columns})`;
 }
 function compileSpecialIndex(driver, tableName, index) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const indexName = index.name ?? defaultIndexName(tableName, index.columns, index.kind);
   const columns = index.columns.map((column) => quoteIdentifier(column)).join(", ");
   switch (index.kind) {

package/dist/entries/tenant/enableTenantRls.js

@@ -175,6 +175,9 @@ function postgresAppRoleCreateSql(options = {}) {
   const password = quoteSqlLiteral(options.password ?? POSTGRES_APP_ROLE_PASSWORD);
   return `DO $$
 BEGIN
+  -- pg_authid is shared across databases. Database-local advisory locks cannot
+  -- serialize a cluster-global role. This lock permits readers and lasts until commit.
+  LOCK TABLE pg_catalog.pg_authid IN SHARE ROW EXCLUSIVE MODE;
   IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${role}') THEN
     CREATE ROLE ${role} LOGIN PASSWORD ${password}
       NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS;
@@ -216,8 +219,7 @@ async function grantPostgresAppRolePrivileges(sql, options) {
   await sql.unsafe(`ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT EXECUTE ON FUNCTIONS TO ${role}`);
 }
 async function ensurePostgresAppRole(sql, options) {
-  await sql.unsafe(postgresAppRoleCreateSql(options));
-  await grantPostgresAppRolePrivileges(sql, options);
+  await sql.unsafe(postgresAppRoleSql(options));
 }
 async function ensurePostgresDatabaseAndAppRole(options) {
   const name = postgresDatabaseNameFromUrl(options.runtimeUrl);

package/dist/index.js

@@ -7733,6 +7733,8 @@ class Blueprint {
   action;
   columns = [];
   indexes = [];
+  foreignKeys = [];
+  checks = [];
   droppedColumns = [];
   droppedIndexes = [];
   constructor(table, action) {
@@ -7747,6 +7749,9 @@ class Blueprint {
     return column;
   }
   string(name, length) {
+    if (length !== undefined && (!Number.isSafeInteger(length) || length <= 0)) {
+      throw new Error("String length must be a positive safe integer.");
+    }
     const column = new ColumnDefinition(name, "string");
     column.length = length;
     column.notNullable();
@@ -7824,6 +7829,22 @@ class Blueprint {
       kind: "unique"
     });
   }
+  foreignKey(columns, referencesTable, referencesColumns, options = {}) {
+    if (!columns.length || columns.length !== referencesColumns.length) {
+      throw new Error("Foreign key columns must be nonempty and match referenced columns.");
+    }
+    this.foreignKeys.push({
+      columns: [...columns],
+      referencesTable,
+      referencesColumns: [...referencesColumns],
+      ...options
+    });
+  }
+  check(expression, name) {
+    if (!expression.trim())
+      throw new Error("Check expression must not be empty.");
+    this.checks.push({ expression, name });
+  }
   index(columns, options = {}) {
     this.indexes.push({
       name: options.name,
@@ -7867,6 +7888,9 @@ class UnsupportedSchemaFeatureError extends Error {
     this.name = "UnsupportedSchemaFeatureError";
   }
 }
+// ../../src/core/database/schema/grammars/compileStatements.ts
+init_dialect();
+
 // ../../src/core/database/schema/grammars/grammar.ts
 function compileColumnType(driver, column) {
   switch (column.kind) {
@@ -7906,7 +7930,7 @@ function compileIdType(driver) {
 function compileStringType(driver, length) {
   switch (driver) {
     case "pgsql":
-      return "TEXT";
+      return length ? `VARCHAR(${length})` : "TEXT";
     case "mysql":
       return length ? `VARCHAR(${length})` : "VARCHAR(255)";
     case "sqlite":
@@ -7984,15 +8008,30 @@ function compileJsonbType(driver) {
 }
 
 // ../../src/core/database/schema/grammars/compileStatements.ts
+function compileTableConstraints(driver, blueprint) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
+  const named = (name) => name ? `CONSTRAINT ${quoteIdentifier(name)} ` : "";
+  const columns = (names) => names.map(quoteIdentifier).join(", ");
+  return [
+    ...blueprint.foreignKeys.map((key) => {
+      const deletion = key.onDelete ? ` ON DELETE ${key.onDelete.toUpperCase()}` : "";
+      return `${named(key.name)}FOREIGN KEY (${columns(key.columns)}) REFERENCES ${quoteIdentifier(key.referencesTable)}(${columns(key.referencesColumns)})${deletion}`;
+    }),
+    ...blueprint.checks.map((check) => `${named(check.name)}CHECK (${check.expression})`)
+  ];
+}
 function compileCreateTable(driver, blueprint) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const table = quoteIdentifier(blueprint.table);
   const parts = blueprint.columns.map((column) => compileColumn(driver, column, "create"));
   for (const index of blueprint.indexes) {
-    if (index.kind === "unique" && index.columns.length > 1) {
+    if (index.kind === "unique") {
       const columns = index.columns.map((column) => quoteIdentifier(column)).join(", ");
-      parts.push(`UNIQUE (${columns})`);
+      const name = index.name ? `CONSTRAINT ${quoteIdentifier(index.name)} ` : "";
+      parts.push(`${name}UNIQUE (${columns})`);
     }
   }
+  parts.push(...compileTableConstraints(driver, blueprint));
   const statements = [`CREATE TABLE IF NOT EXISTS ${table} (
   ${parts.join(`,
   `)}
@@ -8010,6 +8049,7 @@ function compileCreateTable(driver, blueprint) {
   return statements;
 }
 function compileAlterTable(driver, blueprint) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const statements = [];
   const table = quoteIdentifier(blueprint.table);
   for (const column of blueprint.columns) {
@@ -8017,12 +8057,20 @@ function compileAlterTable(driver, blueprint) {
     statements.push(`ALTER TABLE ${table}
 ${addPrefix} ${compileColumn(driver, column, "alter")}`);
   }
+  if (blueprint.foreignKeys.length || blueprint.checks.length) {
+    if (driver === "sqlite") {
+      throw new UnsupportedSchemaFeatureError("adding table constraints; rebuild the SQLite table", driver);
+    }
+    for (const constraint of compileTableConstraints(driver, blueprint)) {
+      statements.push(`ALTER TABLE ${table} ADD ${constraint}`);
+    }
+  }
   for (const columnName of blueprint.droppedColumns) {
     const dropPrefix = driver === "pgsql" ? "DROP COLUMN IF EXISTS" : "DROP COLUMN";
     statements.push(`ALTER TABLE ${table} ${dropPrefix} ${quoteIdentifier(columnName)}`);
   }
   for (const indexName of blueprint.droppedIndexes) {
-    statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`);
+    statements.push(driver === "mysql" ? `DROP INDEX ${quoteIdentifier(indexName)} ON ${table}` : `DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`);
   }
   for (const index of blueprint.indexes) {
     if (index.kind === "index" || index.kind === "unique") {
@@ -8034,10 +8082,12 @@ ${addPrefix} ${compileColumn(driver, column, "alter")}`);
   return statements;
 }
 function compileDropTable(driver, tableName) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const cascade = driver === "pgsql" ? " CASCADE" : "";
   return [`DROP TABLE IF EXISTS ${quoteIdentifier(tableName)}${cascade}`];
 }
 function compileColumn(driver, column, mode) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const parts = [quoteIdentifier(column.name), compileColumnType(driver, column)];
   if (column.autoIncrement && driver === "mysql") {
     parts[1] = `${parts[1]} AUTO_INCREMENT`;
@@ -8075,7 +8125,8 @@ function compileColumn(driver, column, mode) {
   }
   return parts.join(" ");
 }
-function compileIndex(_driver, tableName, index) {
+function compileIndex(driver, tableName, index) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const indexName = index.name ?? defaultIndexName(tableName, index.columns, index.kind === "unique" ? "unique" : "index");
   const columns = index.columns.map((column) => {
     const quoted = quoteIdentifier(column);
@@ -8085,9 +8136,11 @@ function compileIndex(_driver, tableName, index) {
     return quoted;
   }).join(", ");
   const unique = index.kind === "unique" ? "UNIQUE " : "";
-  return `CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)}(${columns})`;
+  const existence = driver === "mysql" ? "" : "IF NOT EXISTS ";
+  return `CREATE ${unique}INDEX ${existence}${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)}(${columns})`;
 }
 function compileSpecialIndex(driver, tableName, index) {
+  const quoteIdentifier = dialectFor(driver).quoteIdentifier;
   const indexName = index.name ?? defaultIndexName(tableName, index.columns, index.kind);
   const columns = index.columns.map((column) => quoteIdentifier(column)).join(", ");
   switch (index.kind) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",