rado 1.0.4 → 1.0.6

package/dist/core/Column.d.ts

@@ -11,7 +11,8 @@ export interface ColumnData {
     notNull?: boolean;
     isUnique?: boolean;
     autoIncrement?: boolean;
-    defaultValue?(): Sql;
+    $default?(): Sql;
+    defaultValue?: Sql;
     references?(): FieldData;
     onUpdate?: Sql;
     onDelete?: Sql;
@@ -23,7 +24,9 @@ export declare class Column<Value = unknown> {
     readonly [internalData]: ColumnData;
     constructor(data: ColumnData);
     notNull(): RequiredColumn<Value>;
-    default(value: Input<WithoutNull<Value>> | (() => Input<WithoutNull<Value>>)): Column<WithoutNull<Value>>;
+    $defaultFn(value: () => Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
+    $default(value: Input<WithoutNull<Value>> | (() => Input<WithoutNull<Value>>)): Column<WithoutNull<Value>>;
+    default(value: Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
     defaultNow(): Column<WithoutNull<Value>>;
     primaryKey(): Column<WithoutNull<Value>>;
     unique(name?: string): Column<Value>;

package/dist/core/Column.js

@@ -13,20 +13,27 @@ var Column = class _Column {
       notNull: true
     });
   }
-  default(value) {
+  $defaultFn(value) {
+    return this.$default(value);
+  }
+  $default(value) {
     return new _Column({
       ...getData(this),
-      defaultValue() {
+      $default() {
         return input(value instanceof Function ? value() : value);
       }
     });
   }
+  default(value) {
+    return new _Column({
+      ...getData(this),
+      defaultValue: input(value)
+    });
+  }
   defaultNow() {
     return new _Column({
       ...getData(this),
-      defaultValue() {
-        return sql.unsafe("now()");
-      }
+      defaultValue: sql.unsafe("now()")
     });
   }
   primaryKey() {

package/dist/core/Emitter.js

@@ -65,7 +65,7 @@ var Emitter = class {
       column.notNull && sql`not null`,
       column.isUnique && sql`unique`,
       column.autoIncrement && sql`autoincrement`,
-      column.defaultValue && sql`default ${column.defaultValue()}`,
+      column.defaultValue && sql`default ${column.defaultValue}`,
       column.references && sql`references ${sql.chunk("emitReferences", [column.references()])}`,
       column.onUpdate && sql`on update ${column.onUpdate}`
     ]).emitTo(this);

package/dist/core/Query.d.ts

@@ -32,7 +32,7 @@ export declare abstract class Query<Result, Meta extends QueryMeta> extends Exec
     get(db?: HasResolver): Deliver<Meta, Result | null>;
     run(db?: HasResolver): Deliver<Meta, void>;
     prepare<Inputs extends Record<string, unknown>>(name?: string): PreparedQuery<Result, Inputs, Meta>;
-    toSQL(): {
+    toSQL(db?: HasResolver): {
         sql: string;
         params: Array<unknown>;
     };

package/dist/core/Query.js

@@ -80,8 +80,8 @@ var Query = class extends Executable {
   prepare(name) {
     return getData(this).resolver.prepare(this, name);
   }
-  toSQL() {
-    const { resolver } = getData(this);
+  toSQL(db) {
+    const resolver = db ? getResolver(db) : getData(this).resolver;
     if (!resolver)
       throw new Error("Query has no resolver");
     return resolver.toSQL(this);

package/dist/core/Sql.d.ts

@@ -29,6 +29,7 @@ export declare class Sql<Value = unknown> implements HasSql<Value> {
     field(field: FieldData): Sql<Value>;
     add(sql: HasSql): Sql<Value>;
     value(value: unknown): Sql<Value>;
+    getValue(): Value | undefined;
     inline(value: unknown): Sql<Value>;
     jsonPath(path: Array<string | number>): Sql<Value>;
     placeholder(name: string): Sql<Value>;
@@ -48,7 +49,7 @@ export declare namespace sql {
     export function identifier<T>(identifier: string): Sql<T>;
     export function field<T>(field: FieldData): Sql<T>;
     export function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
-    export function universal(runtimes: Partial<Record<Runtime | 'default', Sql>>): Sql;
+    export function universal<T>(runtimes: Partial<Record<Runtime | 'default', Sql<T>>>): Sql<T>;
     type QueryChunk = HasSql | undefined;
     export function query(ast: Record<string, boolean | QueryChunk | Array<QueryChunk>>): Sql;
     export function join<T>(items: Array<Sql | HasSql | undefined | false>, separator?: Sql): Sql<T>;

package/dist/core/Sql.js

@@ -46,6 +46,13 @@ var Sql = class _Sql {
   value(value) {
     return this.chunk("emitValue", value);
   }
+  getValue() {
+    if (this.#chunks.length !== 1)
+      return;
+    const chunk = this.#chunks[0];
+    if (chunk?.type === "emitValue")
+      return chunk.inner;
+  }
   inline(value) {
     return this.chunk("emitInline", value);
   }
@@ -141,7 +148,7 @@ function sql(strings, ...inner) {
   }
   sql2.chunk = chunk;
   function universal(runtimes) {
-    return chunk("emitUniversal", runtimes);
+    return empty().chunk("emitUniversal", runtimes);
   }
   sql2.universal = universal;
   function query(ast) {

package/dist/core/expr/Conditions.js

@@ -1,5 +1,5 @@
 // src/core/expr/Conditions.ts
-import { getQuery } from "../Internal.js";
+import { getQuery, getSql, hasSql } from "../Internal.js";
 import { sql } from "../Sql.js";
 import { input } from "./Input.js";
 function bool(impl) {
@@ -41,19 +41,21 @@ function not(condition) {
   return bool(sql`not ${input(condition)}`);
 }
 function inArray(left, right) {
-  if (Array.isArray(right)) {
-    if (right.length === 0)
+  const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
+  if (Array.isArray(value)) {
+    if (value.length === 0)
       return sql`false`;
-    return bool(sql`${input(left)} in (${sql.join(right.map(input), sql`, `)})`);
+    return bool(sql`${input(left)} in (${sql.join(value.map(input), sql`, `)})`);
   }
   return bool(sql`${input(left)} in ${input(right)}`);
 }
 function notInArray(left, right) {
-  if (Array.isArray(right)) {
-    if (right.length === 0)
+  const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
+  if (Array.isArray(value)) {
+    if (value.length === 0)
       return sql`true`;
     return bool(
-      sql`${input(left)} not in (${sql.join(right.map(input), sql`, `)})`
+      sql`${input(left)} not in (${sql.join(value.map(input), sql`, `)})`
     );
   }
   return bool(sql`${input(left)} not in ${input(right)}`);

package/dist/core/query/Insert.js

@@ -84,11 +84,11 @@ var InsertInto = class {
         return sql`(${sql.join(
           Object.entries(table.columns).map(([key, column]) => {
             const value = row[key];
-            const { defaultValue, mapToDriverValue } = getData(column);
+            const { $default, mapToDriverValue } = getData(column);
             if (value !== void 0)
               return input(mapToDriverValue?.(value) ?? value);
-            if (defaultValue)
-              return defaultValue();
+            if ($default)
+              return $default();
             return defaultKeyword;
           }),
           sql`, `

package/dist/postgres/diff.js

@@ -113,7 +113,7 @@ var postgresDiff = (hasTable) => {
           {
             type: sql.unsafe(column2.type.toLowerCase()),
             notNull: column2.notNull,
-            defaultValue: column2.defaultValue ? () => sql.unsafe(column2.defaultValue) : void 0
+            defaultValue: column2.defaultValue ? sql.unsafe(column2.defaultValue) : void 0
           }
         ];
       })
@@ -168,8 +168,8 @@ var postgresDiff = (hasTable) => {
             })
           );
         }
-        const localDefault = localInstruction.defaultValue?.();
-        const schemaDefault = schemaInstruction.defaultValue?.();
+        const localDefault = localInstruction.defaultValue;
+        const schemaDefault = schemaInstruction.defaultValue;
         const localDefaultStr = localDefault && inline(localDefault);
         const schemaDefaultStr = schemaDefault && inline(schemaDefault);
         if (localDefaultStr !== schemaDefaultStr) {

package/dist/sqlite/diff.js

@@ -41,7 +41,7 @@ var sqliteDiff = (hasTable) => {
               type: sql.unsafe(column2.type.toLowerCase()),
               notNull: column2.notnull,
               primary: hasSinglePrimaryKey && column2.pk === 1,
-              defaultValue: column2.dflt_value !== null ? () => sql.unsafe(column2.dflt_value) : void 0
+              defaultValue: column2.dflt_value !== null ? sql.unsafe(column2.dflt_value) : void 0
             })
           )
         ];
@@ -142,7 +142,7 @@ var sqliteDiff = (hasTable) => {
       );
       const selection = { ...hasTable };
       for (const name of missingColumns) {
-        selection[name] = getData(tableApi.columns[name]).defaultValue?.() ?? sql`null`;
+        selection[name] = getData(tableApi.columns[name]).defaultValue ?? sql`null`;
       }
       return [
         // Create a new temporary table with the new definition

package/dist/sqlite/functions.d.ts

@@ -1,14 +1,10 @@
-import type { HasQuery, HasSql, HasTable } from '../core/Internal.js';
+import type { HasSql, HasTable } from '../core/Internal.js';
 import { type Sql } from '../core/Sql.js';
 import { type Input } from '../core/expr/Input.js';
 /**:  The count(X) function returns a count of the number of times that X is not NULL in a group. The count(*) function (with no arguments) returns the total number of rows in the group. */
 export declare const count: (x?: HasSql) => Sql<number>;
 /** The iif(X,Y,Z) function returns the value Y if X is true, and Z otherwise. The iif(X,Y,Z) function is logically equivalent to and generates the same bytecode as the CASE HasSql "CASE WHEN X THEN Y ELSE Z END".*/
 export declare const iif: <T>(x: Input<boolean>, y: Input<T>, z: Input<T>) => Sql<T>;
-/**
- * The EXISTS operator always evaluates to one of the integer values 0 and 1. If executing the SELECT statement specified as the right-hand operand of the EXISTS operator would return one or more rows, then the EXISTS operator evaluates to 1. If executing the SELECT would return no rows at all, then the EXISTS operator evaluates to 0.
- */
-export declare const exists: (cursor: HasQuery) => Sql<boolean>;
 /** Use the match operator for the FTS5 module */
 export declare const match: (table: HasTable, searchTerm: Input<string>) => Sql<boolean>;
 /** Returns a real value reflecting the accuracy of the current match */

package/dist/sqlite/functions.js

@@ -4,7 +4,6 @@ import { Functions } from "../core/expr/Functions.js";
 import { input } from "../core/expr/Input.js";
 var count = Functions.count;
 var iif = Functions.iif;
-var exists = Functions.exists;
 var match = Functions.match;
 var bm25 = Functions.bm25;
 var highlight = Functions.highlight;
@@ -101,7 +100,6 @@ export {
   date,
   datetime,
   degrees,
-  exists,
   exp,
   floor,
   group_concat,

package/dist/universal/functions.d.ts

@@ -1,4 +1,4 @@
 import { type Sql } from '../core/Sql.js';
-import type { Input } from '../core/expr/Input.js';
+import { type Input } from '../core/expr/Input.js';
 export declare function lastInsertId(): Sql<number>;
 export declare function concat(...slices: Array<Input<string | null>>): Sql<string>;

package/dist/universal/functions.js

@@ -1,16 +1,20 @@
 // src/universal/functions.ts
 import { sql } from "../core/Sql.js";
-import { callFunction } from "../core/expr/Functions.js";
+import { Functions } from "../core/expr/Functions.js";
+import { input } from "../core/expr/Input.js";
 var insertId = sql.universal({
-  sqlite: sql`last_insert_rowid()`,
-  postgres: sql`lastval()`,
-  mysql: sql`last_insert_id()`
+  sqlite: Functions.last_insert_rowid(),
+  postgres: Functions.lastval(),
+  mysql: Functions.last_insert_id()
 }).mapWith(Number);
 function lastInsertId() {
   return insertId;
 }
 function concat(...slices) {
-  return callFunction(sql`concat`, slices);
+  return sql.universal({
+    mysql: Functions.concat(...slices),
+    default: sql.join(slices.map(input), sql` || `)
+  });
 }
 export {
   concat,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "license": "MIT",
   "type": "module",
   "scripts": {