rado 1.0.0 → 1.0.2

package/README.md

@@ -20,7 +20,7 @@ Conditions can be created by accessing the fields of the table:
 
 ```ts
 import {eq} from 'rado'
-eq(User.id.is, 1) // Compare with a value
+eq(User.id, 1) // Compare with a value
 eq(User.id, Post.userId) // Compare to fields on other tables
 ```
 

package/dist/core/Dialect.js

@@ -2,7 +2,7 @@
 import {
   getQuery,
   getSql,
-  hasSql
+  hasQuery
 } from "./Internal.js";
 var Dialect = class {
   #createEmitter;
@@ -10,13 +10,13 @@ var Dialect = class {
     this.#createEmitter = createEmitter;
   }
   emit = (input) => {
-    const sql = hasSql(input) ? getSql(input) : getQuery(input);
+    const sql = hasQuery(input) ? getQuery(input) : getSql(input);
     const emitter = new this.#createEmitter();
     sql.emitTo(emitter);
     return emitter;
   };
   inline = (input) => {
-    const sql = hasSql(input) ? getSql(input) : getQuery(input);
+    const sql = hasQuery(input) ? getQuery(input) : getSql(input);
     const emitter = new this.#createEmitter();
     sql.inlineValues().emitTo(emitter);
     return emitter.sql;

package/dist/core/Emitter.d.ts

@@ -1,6 +1,8 @@
 import type { ColumnData } from './Column.js';
 import { type HasQuery, type HasTarget } from './Internal.js';
+import type { Runtime } from './MetaData.js';
 import { type Param } from './Param.js';
+import { type Sql } from './Sql.js';
 import type { TableApi } from './Table.js';
 import type { FieldData } from './expr/Field.js';
 import type { IncludeData } from './expr/Include.js';
@@ -15,16 +17,12 @@ export declare abstract class Emitter {
     get hasParams(): boolean;
     bind(inputs?: Record<string, unknown>): Array<unknown>;
     processValue(value: unknown): unknown;
-    abstract jsonArrayFn: string;
-    abstract jsonGroupFn: string;
+    abstract runtime: Runtime;
     abstract emitIdentifier(value: string): void;
     abstract emitValue(value: unknown): void;
     abstract emitInline(value: unknown): void;
     abstract emitJsonPath(value: Array<number | string>): void;
     abstract emitPlaceholder(value: string): void;
-    abstract emitDefaultValue(): void;
-    abstract emitLastInsertId(): void;
-    abstract emitIdColumn(): void;
     emitUnsafe(value: string): void;
     emitField(field: FieldData): void;
     emitCreateTable(tableApi: TableApi): void;
@@ -37,4 +35,5 @@ export declare abstract class Emitter {
     emitUpdate(update: Update<unknown>): void;
     emitWith(cte: Array<HasQuery & HasTarget>): void;
     emitInclude(data: IncludeData): void;
+    emitUniversal(runtimes: Partial<Record<Runtime | 'default', Sql>>): void;
 }

package/dist/core/Emitter.js

@@ -7,6 +7,8 @@ import {
 } from "./Internal.js";
 import { ValueParam } from "./Param.js";
 import { sql } from "./Sql.js";
+import { callFunction } from "./expr/Functions.js";
+import { jsonAggregateArray, jsonArray } from "./expr/Json.js";
 var Emitter = class {
   sql = "";
   params = [];
@@ -54,13 +56,10 @@ var Emitter = class {
     ]).emitTo(this);
   }
   emitReferences(fields) {
-    sql.join([
+    callFunction(
       sql.identifier(fields[0].targetName),
-      sql`(${sql.join(
-        fields.map((field) => sql.identifier(field.fieldName)),
-        sql`, `
-      )})`
-    ]).emitTo(this);
+      fields.map((field) => sql.identifier(field.fieldName))
+    ).emitTo(this);
   }
   emitDelete(deleteOp) {
     const { cte, from, where, returning } = getData(deleteOp);
@@ -148,13 +147,16 @@ var Emitter = class {
     if (!data.select.selection)
       throw new Error("No selection defined");
     const fields = data.select.selection.fieldNames();
-    let subject = sql`${sql.unsafe(this.jsonArrayFn)}(${sql.join(
-      fields.map((name) => sql`_.${sql.identifier(name)}`),
-      sql`, `
-    )})`;
-    if (!data.first)
-      subject = sql`${sql.unsafe(this.jsonGroupFn)}(${subject})`;
-    sql`(select ${subject} from (${inner}) as _)`.emitTo(this);
+    const subject = jsonArray(
+      ...fields.map((name) => sql`_.${sql.identifier(name)}`)
+    );
+    sql`(select ${data.first ? subject : jsonAggregateArray(subject)} from (${inner}) as _)`.emitTo(this);
+  }
+  emitUniversal(runtimes) {
+    const sql2 = runtimes[this.runtime] ?? runtimes.default;
+    if (!sql2)
+      throw new Error("Unsupported runtime");
+    sql2.emitTo(this);
   }
 };
 export {

package/dist/core/MetaData.d.ts

@@ -1,5 +1,6 @@
 export type QueryMode = 'sync' | 'async' | undefined;
-export type QueryDialect = 'universal' | 'sqlite' | 'mysql' | 'postgres';
+export type Runtime = 'sqlite' | 'mysql' | 'postgres';
+export type QueryDialect = 'universal' | Runtime;
 export type Deliver<Meta extends QueryMeta, Result> = Meta extends Either ? Result | Promise<Result> : Meta extends Sync ? Result : Promise<Result>;
 export interface QueryMeta {
     mode: QueryMode;

package/dist/core/Query.d.ts

@@ -1,4 +1,4 @@
-import { type HasQuery, type HasResolver, type HasSql, type HasTarget, internalData, internalQuery } from './Internal.js';
+import { internalData, internalQuery, type HasQuery, type HasResolver, type HasSql, type HasTarget } from './Internal.js';
 import type { Deliver, QueryMeta } from './MetaData.js';
 import type { PreparedStatement, Resolver } from './Resolver.js';
 import type { Sql } from './Sql.js';
@@ -26,7 +26,7 @@ export declare abstract class Query<Result, Meta extends QueryMeta> extends Exec
     abstract [internalQuery]: Sql;
     constructor(data: QueryData<Meta>);
     all(db?: HasResolver): Deliver<Meta, Array<Result>>;
-    get(db?: HasResolver): Deliver<Meta, Result>;
+    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(): {

package/dist/core/Query.js

@@ -60,9 +60,9 @@ var Query = class extends Executable {
     try {
       const result = prepared[resultType]();
       if (result instanceof Promise)
-        return result.finally(prepared.free.bind(prepared));
+        return result.then((res) => res ?? null).finally(prepared.free.bind(prepared));
       prepared.free();
-      return result;
+      return result ?? null;
     } catch (error) {
       prepared.free();
       throw error;

package/dist/core/Sql.d.ts

@@ -1,6 +1,7 @@
 import type { DriverSpecs } from './Driver.js';
 import type { Emitter } from './Emitter.js';
-import { internalSql, type HasSql } from './Internal.js';
+import { type HasSql, internalSql } from './Internal.js';
+import type { Runtime } from './MetaData.js';
 import type { FieldData } from './expr/Field.js';
 type EmitMethods = {
     [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
@@ -45,6 +46,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;
     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

@@ -136,6 +136,10 @@ function sql(strings, ...inner) {
     return empty().chunk(type, inner);
   }
   sql2.chunk = chunk;
+  function universal(runtimes) {
+    return chunk("emitUniversal", runtimes);
+  }
+  sql2.universal = universal;
   function query(ast) {
     return join(
       Object.entries(ast).map(([key, value2]) => {

package/dist/core/expr/Functions.d.ts

@@ -1,5 +1,6 @@
 import { type Sql } from '../Sql.js';
 import { type Input } from './Input.js';
+export declare function callFunction<Result>(name: Sql, args: Array<Input<unknown>>): Sql<Result>;
 export declare const Functions: Functions;
 export type Functions = {
     [key: string]: (...args: Array<Input<any>>) => Sql<any>;

package/dist/core/expr/Functions.js

@@ -1,12 +1,16 @@
 // src/core/expr/Functions.ts
 import { sql } from "../Sql.js";
 import { input } from "./Input.js";
+function callFunction(name, args) {
+  return sql`${name}(${sql.join(args.map(input), sql`, `)})`;
+}
 function get(target, method) {
   return target[method] ??= (...args) => {
-    return sql`${sql.identifier(method)}(${sql.join(args.map(input), sql`, `)})`;
+    return callFunction(sql.identifier(method), args);
   };
 }
 var Functions = new Proxy(/* @__PURE__ */ Object.create(null), { get });
 export {
-  Functions
+  Functions,
+  callFunction
 };

package/dist/core/expr/Json.d.ts

@@ -1,4 +1,5 @@
 import type { HasSql } from '../Internal.js';
+import type { Input } from './Input.js';
 export interface JsonArrayHasSql<Value> extends HasSql<Array<Value>> {
     [index: number]: JsonExpr<Value>;
 }
@@ -10,4 +11,6 @@ type NullableEach<T> = {
 };
 export type JsonExpr<Value> = [NonNullable<Value>] extends [Array<infer V>] ? JsonArrayHasSql<null extends Value ? V | null : V> : [NonNullable<Value>] extends [object] ? JsonRecordHasSql<null extends Value ? NullableEach<Value> : Value> : HasSql<Value>;
 export declare function jsonExpr<Value>(e: HasSql<Value>): JsonExpr<Value>;
+export declare function jsonAggregateArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
+export declare function jsonArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
 export {};

package/dist/core/expr/Json.js

@@ -1,5 +1,6 @@
 // src/core/expr/Json.ts
 import { sql } from "../Sql.js";
+import { callFunction } from "./Functions.js";
 var INDEX_PROPERTY = /^\d+$/;
 function jsonExpr(e) {
   return new Proxy(e, {
@@ -11,6 +12,27 @@ function jsonExpr(e) {
     }
   });
 }
+function jsonAggregateArray(...args) {
+  return callFunction(
+    sql.universal({
+      sqlite: sql`json_group_array`,
+      postgres: sql`json_agg`,
+      mysql: sql`json_arrayagg`
+    }),
+    args
+  );
+}
+function jsonArray(...args) {
+  return callFunction(
+    sql.universal({
+      postgres: sql`json_build_array`,
+      default: sql`json_array`
+    }),
+    args
+  );
+}
 export {
+  jsonAggregateArray,
+  jsonArray,
   jsonExpr
 };

package/dist/core/query/Insert.js

@@ -66,6 +66,10 @@ var InsertCanConflict = class extends InsertCanReturn {
     });
   }
 };
+var defaultKeyword = sql.universal({
+  sqlite: sql`null`,
+  default: sql`default`
+});
 var InsertInto = class {
   [internalData];
   constructor(data) {
@@ -85,7 +89,7 @@ var InsertInto = class {
               return input(mapToDriverValue?.(value) ?? value);
             if (defaultValue)
               return defaultValue();
-            return sql.chunk("emitDefaultValue", void 0);
+            return defaultKeyword;
           }),
           sql`, `
         )})`;

package/dist/core/query/Select.d.ts

@@ -1,4 +1,4 @@
-import { type HasSelection, type HasSql, type HasTable, type HasTarget, internalData, internalQuery, internalSelection } from '../Internal.js';
+import { internalData, internalQuery, internalSelection, internalSql, type HasSelection, type HasSql, type HasTable, type HasTarget } from '../Internal.js';
 import type { QueryMeta } from '../MetaData.js';
 import type { Query } from '../Query.js';
 import { type IsNullable, type MakeNullable, type Selection, type SelectionRecord, type SelectionRow } from '../Selection.js';
@@ -43,10 +43,11 @@ export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends U
     offset(offset: UserInput<number>): Select<Input, Meta>;
     get [internalSelection](): Selection;
     get [internalQuery](): Sql;
+    get [internalSql](): Sql<SelectionRow<Input>>;
 }
 export type SubQuery<Input> = Input & HasTarget;
-export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<Input, Meta>, HasSelection {
-    where(where: HasSql<boolean>): Select<Input, Meta>;
+export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<Input, Meta>, HasSelection, HasSql<SelectionRow<Input>> {
+    where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
     groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
     having(having: HasSql<boolean>): Select<Input, Meta>;
     orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
@@ -58,7 +59,7 @@ export interface WithoutSelection<Meta extends QueryMeta> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
     from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
 }
-export interface WithSelection<Input, Meta extends QueryMeta> extends Query<SelectionRow<Input>, Meta> {
+export interface WithSelection<Input, Meta extends QueryMeta> extends Query<SelectionRow<Input>, Meta>, HasSql<SelectionRow<Input>> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
     from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
     from(target: HasSql): Select<Input, Meta>;

package/dist/core/query/Select.js

@@ -11,6 +11,7 @@ import {
   internalData,
   internalQuery,
   internalSelection,
+  internalSql,
   internalTarget
 } from "../Internal.js";
 import {
@@ -132,6 +133,9 @@ var Select = class _Select extends UnionBase {
   get [internalQuery]() {
     return sql.chunk("emitSelect", getData(this));
   }
+  get [internalSql]() {
+    return sql`(${getQuery(this)})`;
+  }
 };
 export {
   Select

package/dist/mysql/dialect.js

@@ -10,9 +10,8 @@ var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var mysqlDialect = new Dialect(
   class extends Emitter {
+    runtime = "mysql";
     paramIndex = 0;
-    jsonArrayFn = "json_array";
-    jsonGroupFn = "json_arrayagg";
     emitValue(value) {
       this.sql += "?";
       this.params.push(new ValueParam(value));
@@ -41,15 +40,6 @@ var mysqlDialect = new Dialect(
     emitIdentifier(identifier) {
       this.sql += BACKTICK + identifier.replace(MATCH_BACKTICK, ESCAPE_BACKTICK) + BACKTICK;
     }
-    emitDefaultValue() {
-      this.sql += "default";
-    }
-    emitIdColumn() {
-      this.sql += "int not null auto_increment";
-    }
-    emitLastInsertId() {
-      this.sql += "last_insert_id()";
-    }
   }
 );
 export {

package/dist/postgres/dialect.js

@@ -10,9 +10,8 @@ var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var postgresDialect = new Dialect(
   class extends Emitter {
+    runtime = "postgres";
     paramIndex = 0;
-    jsonArrayFn = "json_build_array";
-    jsonGroupFn = "json_agg";
     emitValue(value) {
       this.sql += `$${++this.paramIndex}`;
       this.params.push(new ValueParam(value));
@@ -49,15 +48,6 @@ var postgresDialect = new Dialect(
     emitIdentifier(identifier) {
       this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
     }
-    emitDefaultValue() {
-      this.sql += "default";
-    }
-    emitIdColumn() {
-      this.sql += "integer generated always as identity";
-    }
-    emitLastInsertId() {
-      this.sql += "lastval()";
-    }
   }
 );
 export {

package/dist/sqlite/dialect.js

@@ -10,8 +10,7 @@ var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var sqliteDialect = new Dialect(
   class extends Emitter {
-    jsonArrayFn = "json_array";
-    jsonGroupFn = "json_group_array";
+    runtime = "sqlite";
     processValue(value) {
       return typeof value === "boolean" ? value ? 1 : 0 : value;
     }
@@ -42,18 +41,9 @@ var sqliteDialect = new Dialect(
     emitIdentifier(identifier) {
       this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
     }
-    emitDefaultValue() {
-      this.sql += "null";
-    }
     quoteString(input) {
       return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
     }
-    emitIdColumn() {
-      this.sql += "integer";
-    }
-    emitLastInsertId() {
-      this.sql += "last_insert_rowid()";
-    }
   }
 );
 export {

package/dist/sqlite/diff.js

@@ -142,7 +142,7 @@ var sqliteDiff = (hasTable) => {
       );
       const selection = { ...hasTable };
       for (const name of missingColumns) {
-        selection[name] = getData(tableApi.columns[name]).defaultValue?.() ?? sql.chunk("emitDefaultValue", void 0);
+        selection[name] = getData(tableApi.columns[name]).defaultValue?.() ?? sql`null`;
       }
       return [
         // Create a new temporary table with the new definition

package/dist/universal/columns.d.ts

@@ -1,4 +1,4 @@
-import { JsonColumn, type Column } from '../core/Column.js';
+import { type Column, JsonColumn } from '../core/Column.js';
 export declare function id(name?: string): Column<number>;
 export declare function text(name?: string): Column<string | null>;
 export declare function integer(name?: string): Column<number | null>;

package/dist/universal/columns.js

@@ -1,10 +1,15 @@
 // src/universal/columns.ts
 import { JsonColumn, column } from "../core/Column.js";
 import { sql } from "../core/Sql.js";
+var idType = sql.universal({
+  sqlite: sql`integer`,
+  postgres: sql`integer generated always as identity`,
+  mysql: sql`int not null auto_increment`
+});
 function id(name) {
   return column({
     name,
-    type: sql.chunk("emitIdColumn", void 0),
+    type: idType,
     primary: true
   });
 }

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,11 +1,16 @@
 // src/universal/functions.ts
 import { sql } from "../core/Sql.js";
-import { input } from "../core/expr/Input.js";
+import { callFunction } from "../core/expr/Functions.js";
+var insertId = sql.universal({
+  sqlite: sql`last_insert_rowid()`,
+  postgres: sql`lastval()`,
+  mysql: sql`last_insert_id()`
+}).mapWith(Number);
 function lastInsertId() {
-  return sql.chunk("emitLastInsertId", void 0).mapWith(Number);
+  return insertId;
 }
 function concat(...slices) {
-  return sql`concat(${sql.join(slices.map(input), sql`, `)})`;
+  return callFunction(sql`concat`, slices);
 }
 export {
   concat,

package/package.json

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