@stacksjs/database 0.70.112 → 0.70.114

package/dist/migrations.js

@@ -615,10 +615,10 @@ export function groupGeneratedStatements(sqlStatements) {
       push(`create-${create[1]}-table`, stmt);
       continue;
     }
-    const alter = stmt.match(/^\s*ALTER\s+TABLE\s+["`]?(\w+)["`]?\s+(?:ADD\s+COLUMN\s+["`]?(\w+)["`]?|DROP\s+COLUMN\s+["`]?(\w+)["`]?|ADD\s+CONSTRAINT)/i);
-    if (alter) {
-      const isCreateTimeConstraint = createdTables.has(alter[1]) && !alter[2] && !alter[3];
-      push(isCreateTimeConstraint ? "create-foreign-key-constraints" : `alter-${alter[1]}-${alter[2] || alter[3] || "constraint"}`, stmt);
+    const alter = stmt.match(/^\s*ALTER\s+TABLE\s+["`]?(\w+)["`]?\s+(?:ADD\s+COLUMN\s+["`]?(\w+)["`]?|DROP\s+COLUMN\s+["`]?(\w+)["`]?|ADD\s+CONSTRAINT)/i), alterTable = alter?.[1];
+    if (alter && alterTable) {
+      const isCreateTimeConstraint = createdTables.has(alterTable) && !alter[2] && !alter[3];
+      push(isCreateTimeConstraint ? "create-foreign-key-constraints" : `alter-${alterTable}-${alter[2] || alter[3] || "constraint"}`, stmt);
       continue;
     }
     const idx = stmt.match(/^\s*CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?\s+ON\s+["`]?(\w+)["`]?/i), idxName = idx?.[1], idxTable = idx?.[2];

package/dist/schema.d.ts

@@ -1,4 +1,11 @@
-/** @defaultValue `{ createTable: () => Promise<unknown> }` */
+/**
+ * @defaultValue
+ * ```ts
+ * {
+ *   createTable: (tableName: string, callback: (table: Table) => void) => Promise<void>
+ * }
+ * ```
+ */
 export declare const Schema: {
   createTable: (tableName: string, callback: (table: Table) => void) => Promise<void>
 };

package/dist/types.d.ts

@@ -8,6 +8,21 @@
  * ```
  */
 export declare function sql(strings: TemplateStringsArray, ...values: unknown[]): Sql;
+/**
+ * Runtime implementation behind `db.fn`. bun-query-builder has no
+ * top-level `fn` accessor (its select pipeline consumes plain SQL
+ * fragments), so the `db` proxy serves this object directly. Every
+ * aggregate renders to a fragment whose `.sql` text the select /
+ * groupBy machinery picks up verbatim, e.g.:
+ *
+ * ```ts
+ * db.selectFrom('query_logs')
+ *   .select(db.fn.count('id').as('count'))
+ *   .execute()
+ * // SELECT COUNT(id) AS count FROM query_logs
+ * ```
+ */
+export declare const aggregateFunctions: ExpressionFunctions;
 /**
  * Type for raw SQL expressions.
  * Used when building dynamic SQL queries.
@@ -24,6 +39,8 @@ export declare interface RawBuilder<T = unknown> {
 export declare interface Sql {
   readonly sql: string
   readonly parameters: unknown[]
+  as: (alias: string) => Sql
+  toString: () => string
 }
 /**
  * Reference to a column for use inside an expression. Returned by
@@ -43,8 +60,13 @@ export declare interface ColumnRef {
  * names the resulting column in the projection; `.filterWhere(...)`
  * scopes the aggregate to a sub-population (`COUNT(*) FILTER (WHERE
  * status = 'success')` style).
+ *
+ * The `sql` text is part of the contract: bun-query-builder's select
+ * pipeline renders fragments from their `.sql` property, so every
+ * chain step returns a fresh expression with the fully rendered text.
  */
 export declare interface AggregateExpression {
+  readonly sql: string
   as: (alias: string) => AggregateExpression
   filterWhere: (column: string, op: ExpressionOperator | string, value: unknown) => AggregateExpression
 }

package/dist/types.js

@@ -1,3 +1,21 @@
+const SAFE_ALIAS = /^[A-Z_][A-Z0-9_]*$/i, SAFE_COLUMN = /^[A-Z_][A-Z0-9_]*(\.[A-Z_][A-Z0-9_]*)?$/i;
+function assertSqlTextIdentifier(value, kind) {
+  if (!(kind === "column" ? SAFE_COLUMN : SAFE_ALIAS).test(value))
+    throw TypeError(`[database] refusing to interpolate unsafe ${kind} ${JSON.stringify(value)} into SQL text - expected a plain identifier (letters, digits, underscores)`);
+}
+function createSqlFragment(text, parameters) {
+  return {
+    sql: text,
+    parameters,
+    as(alias) {
+      assertSqlTextIdentifier(alias, "alias");
+      return createSqlFragment(`${text} AS ${alias}`, parameters);
+    },
+    toString() {
+      return text;
+    }
+  };
+}
 export function sql(strings, ...values) {
   const sqlParts = [], parameters = [];
   for (let i = 0;i < strings.length; i++) {
@@ -10,10 +28,7 @@ export function sql(strings, ...values) {
         parameters.push(values[i]);
       }
   }
-  return {
-    sql: sqlParts.join(""),
-    parameters
-  };
+  return createSqlFragment(sqlParts.join(""), parameters);
 }
 sql.raw = function raw(value) {
   return { raw: value };
@@ -21,3 +36,63 @@ sql.raw = function raw(value) {
 sql.ref = function ref(column) {
   return { raw: column };
 };
+sql.literal = function literal(value) {
+  return { raw: inlineSqlLiteral(value) };
+};
+const SAFE_FILTER_OPERATORS = new Set([
+  "=",
+  "!=",
+  "<>",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "like",
+  "not like",
+  "ilike",
+  "not ilike",
+  "is",
+  "is not"
+]);
+function inlineSqlLiteral(value) {
+  if (value === null || value === void 0)
+    return "NULL";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw TypeError(`[database] refusing to inline non-finite number into SQL: ${value}`);
+    return String(value);
+  }
+  if (typeof value === "boolean")
+    return value ? "1" : "0";
+  if (typeof value === "bigint")
+    return value.toString();
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function createAggregateExpression(text) {
+  return {
+    sql: text,
+    as(alias) {
+      assertSqlTextIdentifier(alias, "alias");
+      return createAggregateExpression(`${text} AS ${alias}`);
+    },
+    filterWhere(column, op, value) {
+      assertSqlTextIdentifier(column, "column");
+      if (!SAFE_FILTER_OPERATORS.has(op.toLowerCase()))
+        throw TypeError(`[database] refusing unsafe aggregate filter operator ${JSON.stringify(op)} - allowed: ${[...SAFE_FILTER_OPERATORS].join(", ")}`);
+      return createAggregateExpression(`${text} FILTER (WHERE ${column} ${op} ${inlineSqlLiteral(value)})`);
+    }
+  };
+}
+function aggregate(name, column) {
+  if (column !== void 0)
+    assertSqlTextIdentifier(column, "column");
+  return createAggregateExpression(column === void 0 ? `${name}(*)` : `${name}(${column})`);
+}
+export const aggregateFunctions = {
+  countAll: () => aggregate("COUNT"),
+  count: (column) => aggregate("COUNT", column),
+  sum: (column) => aggregate("SUM", column),
+  avg: (column) => aggregate("AVG", column),
+  min: (column) => aggregate("MIN", column),
+  max: (column) => aggregate("MAX", column)
+};

package/dist/utils.js

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { createQueryBuilder, setConfig } from "@stacksjs/query-builder";
 import { env as envVars } from "@stacksjs/env";
 import { getConnectionDefaults } from "./defaults";
+import { aggregateFunctions } from "./types";
 const sqliteDefaults = getConnectionDefaults("sqlite", envVars), mysqlDefaults = getConnectionDefaults("mysql", envVars), postgresDefaults = getConnectionDefaults("postgres", envVars);
 let appEnv = envVars.APP_ENV || "local", dbDriver = envVars.DB_CONNECTION || "sqlite", dbConfig = {
   connections: {
@@ -153,6 +154,8 @@ function getDb() {
 ensureConfigLoaded();
 export const db = new Proxy({}, {
   get(_target, prop) {
+    if (prop === "fn")
+      return aggregateFunctions;
     const instance = getDb(), value = instance[prop];
     if (typeof value === "function")
       return value.bind(instance);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.112",
+  "version": "0.70.114",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -55,18 +55,20 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "bun-query-builder": "^0.1.56"
+    "@stacksjs/ts-validation": "^0.5.0",
+    "bun-query-builder": "catalog:",
+    "dynamodb-tooling": "^0.3.2"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.112",
-    "@stacksjs/config": "0.70.112",
-    "@stacksjs/logging": "0.70.112",
-    "@stacksjs/router": "0.70.112",
-    "better-dx": "^0.2.16",
-    "@stacksjs/path": "0.70.112",
-    "@stacksjs/query-builder": "0.70.112",
-    "@stacksjs/storage": "0.70.112",
-    "@stacksjs/strings": "0.70.112",
-    "@stacksjs/utils": "0.70.112"
+    "@stacksjs/cli": "0.70.114",
+    "@stacksjs/config": "0.70.114",
+    "@stacksjs/logging": "0.70.114",
+    "@stacksjs/router": "0.70.114",
+    "better-dx": "catalog:",
+    "@stacksjs/path": "0.70.114",
+    "@stacksjs/query-builder": "0.70.114",
+    "@stacksjs/storage": "0.70.114",
+    "@stacksjs/strings": "0.70.114",
+    "@stacksjs/utils": "0.70.114"
   }
 }