rado 1.0.3 → 1.0.5

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/expr/Conditions.d.ts

@@ -1,6 +1,7 @@
 import { type HasSql } from '../Internal.js';
+import type { Either } from '../MetaData.js';
+import type { Query } from '../Query.js';
 import { type Sql } from '../Sql.js';
-import type { Select } from '../query/Select.js';
 import { type Input } from './Input.js';
 export declare const eq: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
 export declare const ne: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
@@ -18,8 +19,8 @@ export declare const arrayOverlaps: <T>(left: Input<Array<T>>, right: Input<Arra
 export declare function and(...conditions: Array<undefined | Input<boolean>>): Sql<boolean>;
 export declare function or(...conditions: Array<undefined | Input<boolean>>): Sql<boolean>;
 export declare function not(condition: Input<boolean>): Sql<boolean>;
-export declare function inArray<T>(left: Input<T>, right: Input<Array<T>>): Sql<boolean>;
-export declare function notInArray<T>(left: Input<T>, right: Input<Array<T>>): Sql<boolean>;
+export declare function inArray<T>(left: Input<T>, right: Query<T, any> | Input<Array<T>>): Sql<boolean>;
+export declare function notInArray<T>(left: Input<T>, right: Query<T, any> | Input<Array<T>>): Sql<boolean>;
 export declare function isNull(value: Input): Sql<boolean>;
 export declare function isNotNull(value: Input): Sql<boolean>;
 export declare function between<T>(value: Input<T>, left: Input<T>, right: Input<T>): Sql<boolean>;
@@ -29,4 +30,4 @@ export declare function desc<T>(input: HasSql<T>): Sql;
 export declare function distinct<T>(input: HasSql<T>): Sql;
 export declare function when<In, Out>(compare: Input<In>, ...cases: Array<[condition: Input<In>, result: Input<Out>] | Input<Out>>): Sql<Out>;
 export declare function when<Out>(...cases: Array<[condition: Input<boolean>, result: Input<Out>] | Input<Out>>): Sql<Out>;
-export declare function exists<T>(query: Select<T>): Sql<boolean>;
+export declare function exists(query: Query<any, Either>): Sql<boolean>;

package/dist/core/expr/Conditions.js

@@ -2,8 +2,11 @@
 import { getQuery } from "../Internal.js";
 import { sql } from "../Sql.js";
 import { input } from "./Input.js";
+function bool(impl) {
+  return impl.mapWith(Boolean);
+}
 function binop(operator) {
-  return (left, right) => sql`${input(left)} ${sql.unsafe(operator)} ${input(right)}`;
+  return (left, right) => bool(sql`${input(left)} ${sql.unsafe(operator)} ${input(right)}`);
 }
 var eq = binop("=");
 var ne = binop("<>");
@@ -21,49 +24,53 @@ var arrayOverlaps = binop("&&");
 function and(...conditions) {
   const inputs = conditions.filter((v) => v !== void 0).map(input);
   if (inputs.length === 0)
-    return sql`true`;
+    return bool(sql`true`);
   if (inputs.length === 1)
-    return inputs[0];
-  return sql`(${sql.join(inputs, sql` and `)})`;
+    return bool(inputs[0]);
+  return bool(sql`(${sql.join(inputs, sql` and `)})`);
 }
 function or(...conditions) {
   const inputs = conditions.filter((v) => v !== void 0).map(input);
   if (inputs.length === 0)
-    return sql`true`;
+    return bool(sql`true`);
   if (inputs.length === 1)
-    return inputs[0];
-  return sql`(${sql.join(inputs, sql` or `)})`;
+    return bool(inputs[0]);
+  return bool(sql`(${sql.join(inputs, sql` or `)})`);
 }
 function not(condition) {
-  return sql`not ${input(condition)}`;
+  return bool(sql`not ${input(condition)}`);
 }
 function inArray(left, right) {
   if (Array.isArray(right)) {
     if (right.length === 0)
       return sql`false`;
-    return sql`${input(left)} in (${sql.join(right.map(input), sql`, `)})`;
+    return bool(sql`${input(left)} in (${sql.join(right.map(input), sql`, `)})`);
   }
-  return sql`${input(left)} in ${input(right)}`;
+  return bool(sql`${input(left)} in ${input(right)}`);
 }
 function notInArray(left, right) {
   if (Array.isArray(right)) {
     if (right.length === 0)
       return sql`true`;
-    return sql`${input(left)} not in (${sql.join(right.map(input), sql`, `)})`;
+    return bool(
+      sql`${input(left)} not in (${sql.join(right.map(input), sql`, `)})`
+    );
   }
-  return sql`${input(left)} not in ${input(right)}`;
+  return bool(sql`${input(left)} not in ${input(right)}`);
 }
 function isNull(value) {
-  return sql`${input(value)} is null`;
+  return bool(sql`${input(value)} is null`);
 }
 function isNotNull(value) {
-  return sql`${input(value)} is not null`;
+  return bool(sql`${input(value)} is not null`);
 }
 function between(value, left, right) {
-  return sql`${input(value)} between ${input(left)} and ${input(right)}`;
+  return bool(sql`${input(value)} between ${input(left)} and ${input(right)}`);
 }
 function notBetween(value, left, right) {
-  return sql`${input(value)} not between ${input(left)} and ${input(right)}`;
+  return bool(
+    sql`${input(value)} not between ${input(left)} and ${input(right)}`
+  );
 }
 function asc(input2) {
   return sql`${input2} asc`;
@@ -94,7 +101,7 @@ function when(...cases) {
   ]);
 }
 function exists(query) {
-  return sql`exists (${getQuery(query)})`;
+  return bool(sql`exists (${getQuery(query)})`);
 }
 export {
   and,

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/core/query/Select.d.ts

@@ -25,10 +25,10 @@ export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends U
     constructor(data: SelectData<Meta>);
     as(alias: string): SubQuery<Input>;
     from(target: HasTarget | HasSql): Select<Input, Meta>;
-    leftJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
-    rightJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
-    innerJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
-    fullJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    leftJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
+    rightJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
+    innerJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
+    fullJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
     where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
     groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
     having(having: HasSql<boolean> | ((self: Input) => HasSql<boolean>)): Select<Input, Meta>;
@@ -69,8 +69,12 @@ type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
 }>;
 export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
     leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
+    leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
 }
 export {};

package/dist/core/query/Select.js

@@ -4,7 +4,6 @@ import {
   getQuery,
   getSelection,
   getSql,
-  getTable,
   getTarget,
   hasTable,
   hasTarget,
@@ -50,11 +49,11 @@ var Select = class _Select extends UnionBase {
     const { from, select: current } = getData(this);
     return new _Select({
       ...getData(this),
-      select: current?.join(right, operator),
+      select: hasTable(right) ? current?.join(right, operator) : current,
       from: sql.join([
         from,
         sql.unsafe(`${operator} join`),
-        getTable(right).target(),
+        getTarget(right),
         sql`on ${on}`
       ])
     });

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -8,7 +8,7 @@
     "size": "esbuild src/index.ts --bundle --minify --format=esm --outdir=dist",
     "profile": "PROFILE=true bun build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
     "prepublishOnly": "rm -rf dist && bun run build",
-    "cycles": "madge --warning --circular src/index.ts",
+    "cycles": "madge --circular src/index.ts src/sqlite.ts src/mysql.ts src/postgres.ts",
     "test:bun": "bun test",
     "test:node": "node --test-force-exit --test-concurrency=1 --import tsx --test \"**/*.test.ts\"",
     "test:deno": "deno test --no-check --allow-read"