rado 1.0.3 → 1.0.4

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

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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"