rado 0.4.9 → 1.0.0-preview.0

package/dist/core/Selection.js

@@ -0,0 +1,88 @@
+import {
+  getField,
+  getSql,
+  hasField,
+  hasSql,
+  internalSql
+} from "./Internal.ts";
+import { sql } from "./Sql.ts";
+import { virtual } from "./Virtual.ts";
+class Selection {
+  #input;
+  #nullable;
+  constructor(input, nullable) {
+    this.#input = input;
+    this.#nullable = nullable;
+  }
+  makeVirtual(name) {
+    return virtual(name, this.#input);
+  }
+  mapRow = (values) => {
+    return this.#mapResult(this.#input, values);
+  };
+  get [internalSql]() {
+    return this.#selectionToSql(this.#input, /* @__PURE__ */ new Set());
+  }
+  #mapResult(input, values) {
+    const expr = this.#exprOf(input);
+    if (expr) {
+      const value = values.shift();
+      if (value !== null && expr.mapFromDriverValue)
+        return expr.mapFromDriverValue(value);
+      return value;
+    }
+    const result = {};
+    let isNullable = this.#nullable.size > 0;
+    for (const name in input) {
+      const expr2 = input[name];
+      const value = this.#mapResult(expr2, values);
+      result[name] = value;
+      if (isNullable) {
+        if (value === null) {
+          const field = getField(expr2);
+          if (field && !this.#nullable.has(field.targetName))
+            isNullable = false;
+        } else {
+          isNullable = false;
+        }
+      }
+    }
+    if (isNullable)
+      return null;
+    return result;
+  }
+  #selectionToSql(input, names, name) {
+    const expr = this.#exprOf(input);
+    if (expr) {
+      let exprName = name ?? expr.alias;
+      if (exprName) {
+        while (names.has(exprName))
+          exprName = `${exprName}_`;
+        names.add(exprName);
+        if (hasField(input)) {
+          const field = getField(input);
+          if (field.fieldName === exprName)
+            return expr;
+        }
+        return sql`${expr} as ${sql.identifier(exprName)}`;
+      }
+      return expr;
+    }
+    return sql.join(
+      Object.entries(input).map(
+        ([name2, value]) => this.#selectionToSql(value, names, name2)
+      ),
+      sql`, `
+    );
+  }
+  #exprOf(input) {
+    return hasSql(input) ? getSql(input) : void 0;
+  }
+}
+function selection(input, nullable = /* @__PURE__ */ new Set()) {
+  return new Selection(input, nullable);
+}
+export {
+  Selection,
+  selection
+};

package/dist/core/Sql.d.ts

@@ -0,0 +1,49 @@
+import type { Emitter } from './Emitter.ts';
+import { internalSql, type HasSql } from './Internal.ts';
+import type { FieldData } from './expr/Field.ts';
+type EmitMethods = {
+    [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
+};
+declare class Chunk<Type = keyof EmitMethods, Inner = unknown> {
+    type: Type;
+    inner: Inner;
+    constructor(type: Type, inner: Inner);
+}
+export type Decoder<T> = ((value: unknown) => T) | {
+    mapFromDriverValue?(value: unknown): T;
+};
+export declare class Sql<Value = unknown> implements HasSql<Value> {
+    #private;
+    private brand;
+    alias?: string;
+    mapFromDriverValue?: (input: unknown) => Value;
+    readonly [internalSql]: this;
+    constructor(chunks?: Array<Chunk>);
+    as(name: string): Sql<Value>;
+    mapWith<T = Value>(decoder: Decoder<T>): Sql<T>;
+    chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql<Value>;
+    unsafe(sql: string): Sql<Value>;
+    field(field: FieldData): Sql<Value>;
+    add(sql: HasSql): Sql<Value>;
+    value(value: unknown): Sql<Value>;
+    inline(value: unknown): Sql<Value>;
+    jsonPath(path: Array<string | number>): Sql<Value>;
+    placeholder(name: string): Sql<Value>;
+    identifier(identifier: string): Sql<Value>;
+    inlineFields(withTableName: boolean): Sql<Value>;
+    emit(emitter: Emitter): void;
+}
+export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql>): Sql<T>;
+export declare namespace sql {
+    function empty<T>(): Sql<T>;
+    function unsafe<T>(directSql: string): Sql<T>;
+    function value<T>(value: T): Sql<T>;
+    function inline<T>(value: T): Sql<T>;
+    function placeholder<T>(name: string): Sql<T>;
+    function identifier<T>(identifier: string): Sql<T>;
+    function field<T>(field: FieldData): Sql<T>;
+    function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
+    function query(ast: Record<string, HasSql | undefined>): Sql;
+    function join<T>(items: Array<Sql | HasSql | undefined | false>, separator?: Sql): Sql<T>;
+}
+export {};

package/dist/core/Sql.js

@@ -0,0 +1,153 @@
+import { getSql, internalSql } from "./Internal.ts";
+class Chunk {
+  constructor(type, inner) {
+    this.type = type;
+    this.inner = inner;
+  }
+}
+class Sql {
+  alias;
+  mapFromDriverValue;
+  [internalSql] = this;
+  #chunks;
+  constructor(chunks = []) {
+    this.#chunks = chunks;
+  }
+  as(name) {
+    this.alias = name;
+    return this;
+  }
+  mapWith(decoder) {
+    const res = this;
+    res.mapFromDriverValue = typeof decoder === "function" ? decoder : decoder.mapFromDriverValue;
+    return res;
+  }
+  chunk(type, inner) {
+    this.#chunks.push(new Chunk(type, inner));
+    return this;
+  }
+  unsafe(sql2) {
+    if (sql2.length > 0)
+      this.chunk("emitUnsafe", sql2);
+    return this;
+  }
+  field(field) {
+    return this.chunk("emitField", field);
+  }
+  add(sql2) {
+    const inner = getSql(sql2);
+    if (!(inner instanceof Sql))
+      throw new Error("Invalid SQL");
+    this.#chunks.push(...inner.#chunks);
+    return this;
+  }
+  value(value) {
+    return this.chunk("emitValue", value);
+  }
+  inline(value) {
+    return this.chunk("emitInline", value);
+  }
+  jsonPath(path) {
+    const last = this.#chunks.at(-1);
+    if (last?.type === "emitJsonPath")
+      last.inner.push(...path);
+    else
+      this.chunk("emitJsonPath", path);
+    return this;
+  }
+  placeholder(name) {
+    return this.chunk("emitPlaceholder", name);
+  }
+  identifier(identifier) {
+    return this.chunk("emitIdentifier", identifier);
+  }
+  inlineFields(withTableName) {
+    return new Sql(
+      this.#chunks.flatMap((chunk) => {
+        if (chunk.type !== "emitField")
+          return [chunk];
+        const data = chunk.inner;
+        if (withTableName)
+          return [
+            new Chunk("emitIdentifier", data.targetName),
+            new Chunk("emitUnsafe", "."),
+            new Chunk("emitIdentifier", data.fieldName)
+          ];
+        return [new Chunk("emitIdentifier", data.fieldName)];
+      })
+    );
+  }
+  emit(emitter) {
+    for (const chunk of this.#chunks)
+      emitter[chunk.type](chunk.inner);
+  }
+}
+function sql(strings, ...inner) {
+  const sql2 = new Sql();
+  for (let i = 0; i < strings.length; i++) {
+    sql2.unsafe(strings[i]);
+    if (i < inner.length) {
+      const insert = inner[i];
+      sql2.add(insert);
+    }
+  }
+  return sql2;
+}
+((sql2) => {
+  function empty() {
+    return new Sql();
+  }
+  sql2.empty = empty;
+  function unsafe(directSql) {
+    return empty().unsafe(directSql);
+  }
+  sql2.unsafe = unsafe;
+  function value(value2) {
+    return empty().value(value2);
+  }
+  sql2.value = value;
+  function inline(value2) {
+    return empty().inline(value2);
+  }
+  sql2.inline = inline;
+  function placeholder(name) {
+    return empty().placeholder(name);
+  }
+  sql2.placeholder = placeholder;
+  function identifier(identifier2) {
+    return empty().identifier(identifier2);
+  }
+  sql2.identifier = identifier;
+  function field(field2) {
+    return empty().field(field2);
+  }
+  sql2.field = field;
+  function chunk(type, inner) {
+    return empty().chunk(type, inner);
+  }
+  sql2.chunk = chunk;
+  function query(ast) {
+    return join(
+      Object.entries(ast).map(([key, value2]) => {
+        const statement = key.replace(/([A-Z])/g, " $1").toLocaleLowerCase();
+        return value2 && sql2`${sql2.unsafe(statement)} ${value2}`;
+      })
+    );
+  }
+  sql2.query = query;
+  function join(items, separator = sql2` `) {
+    const parts = items.filter(Boolean);
+    const sql3 = new Sql();
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0)
+        sql3.add(separator);
+      sql3.add(parts[i]);
+    }
+    return sql3;
+  }
+  sql2.join = join;
+})(sql || (sql = {}));
+export {
+  Sql,
+  sql
+};

package/dist/core/Table.d.ts

@@ -0,0 +1,56 @@
+import type { Column, JsonColumn, RequiredColumn } from './Column.ts';
+import type { ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from './Constraint.ts';
+import type { Index } from './Index.ts';
+import { type HasSql, type HasTable, type HasTarget } from './Internal.ts';
+import { type Sql } from './Sql.ts';
+import { type JsonExpr } from './expr/Conditions.ts';
+import { Field } from './expr/Field.ts';
+import type { Input } from './expr/Input.ts';
+export type TableDefinition = {
+    [name: string]: Column;
+};
+declare class TableData {
+    name: string;
+    alias?: string;
+    schemaName?: string;
+    columns: TableDefinition;
+    config?: TableConfig;
+}
+export declare class TableApi<Definition extends TableDefinition = TableDefinition, Name extends string = string> extends TableData {
+    private brand;
+    get aliased(): string;
+    target(): Sql;
+    createDefinition(): Sql;
+    listColumns(): Sql;
+    fields(): Record<string, HasSql>;
+}
+export type Table<Definition extends TableDefinition = TableDefinition, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasTarget;
+export type TableFields<Definition extends TableDefinition, TableName extends string = string> = {
+    [K in keyof Definition]: Definition[K] extends JsonColumn<infer T> ? JsonExpr<T> : Definition[K] extends Column<infer T> ? Field<T, TableName> : never;
+};
+export type TableRow<Definition extends TableDefinition> = {
+    [K in keyof Definition]: Definition[K] extends Column<infer T> ? T : never;
+} & {};
+type IsReq<Col> = Col extends RequiredColumn ? true : false;
+type Required<D> = {
+    [K in keyof D as true extends IsReq<D[K]> ? K : never]: D[K];
+};
+type Optional<D> = {
+    [K in keyof D as false extends IsReq<D[K]> ? K : never]: D[K];
+};
+type RequiredInput<D> = {
+    readonly [K in keyof Required<D>]: D[K] extends Column<infer V> ? Input<V> : never;
+};
+type OptionalInput<D> = {
+    readonly [K in keyof Optional<D>]?: D[K] extends Column<infer V> ? Input<V> : never;
+};
+export type TableInsert<Definition extends TableDefinition> = RequiredInput<Definition> & OptionalInput<Definition>;
+export type TableUpdate<Definition extends TableDefinition> = {
+    readonly [K in keyof Definition]?: Definition[K] extends Column<infer T> ? Input<T> : never;
+};
+export type TableConfigSetting<Name extends string> = UniqueConstraint<Name> | PrimaryKeyConstraint<Name> | ForeignKeyConstraint<Name> | Index<Name>;
+export interface TableConfig<Name extends string = string> extends Record<string, TableConfigSetting<Name>> {
+}
+export declare function table<Definition extends TableDefinition, Name extends string>(name: Name, columns: Definition, config?: (self: Table<Definition, Name>) => TableConfig<Name>, schemaName?: string): Table<Definition, Name>;
+export declare function alias<Definition extends TableDefinition, Alias extends string>(table: Table<Definition>, alias: Alias): Table<Definition, Alias>;
+export {};

package/dist/core/Table.js

@@ -0,0 +1,103 @@
+import {
+  getColumn,
+  getConstraint,
+  getTable,
+  hasConstraint,
+  internalTable,
+  internalTarget
+} from "./Internal.ts";
+import { sql } from "./Sql.ts";
+import { jsonExpr } from "./expr/Conditions.ts";
+import { Field } from "./expr/Field.ts";
+const { assign, fromEntries, entries } = Object;
+class TableData {
+  name;
+  alias;
+  schemaName;
+  columns;
+  config;
+}
+class TableApi extends TableData {
+  get aliased() {
+    return this.alias ?? this.name;
+  }
+  target() {
+    const name = sql.join(
+      [
+        this.schemaName ? sql.identifier(this.schemaName) : void 0,
+        sql.identifier(this.name)
+      ],
+      sql`.`
+    );
+    return sql.join([
+      name,
+      this.alias ? sql`as ${sql.identifier(this.alias)}` : void 0
+    ]);
+  }
+  createDefinition() {
+    const createColumns = entries(this.columns).map(([name, isColumn]) => {
+      const column = getColumn(isColumn);
+      const columnName = sql.identifier(column.name ?? name);
+      return sql`${columnName} ${sql.chunk("emitColumn", column)}`;
+    });
+    const createConstraints = entries(this.config ?? {}).filter(([, constraint]) => hasConstraint(constraint)).map(
+      ([name, constraint]) => sql`constraint ${sql.identifier(name)} ${getConstraint(
+        constraint
+      )}`
+    );
+    return sql.join(createColumns.concat(createConstraints), sql`, `);
+  }
+  listColumns() {
+    return sql.join(
+      entries(this.columns).map(([name, column]) => {
+        const columnApi = getColumn(column);
+        const { name: givenName } = columnApi;
+        return sql.identifier(givenName ?? name);
+      }),
+      sql`, `
+    );
+  }
+  fields() {
+    return fromEntries(
+      entries(this.columns).map(([name, column]) => {
+        const columnApi = getColumn(column);
+        const { name: givenName } = columnApi;
+        const field = new Field(this.aliased, givenName ?? name, columnApi);
+        if (columnApi.json)
+          return [name, jsonExpr(field)];
+        return [name, field];
+      })
+    );
+  }
+}
+function table(name, columns, config, schemaName) {
+  const api = assign(new TableApi(), {
+    name,
+    schemaName,
+    columns
+  });
+  const table2 = {
+    [internalTable]: api,
+    [internalTarget]: api.target(),
+    ...api.fields()
+  };
+  if (config)
+    api.config = config(table2);
+  return table2;
+}
+function alias(table2, alias2) {
+  const api = assign(new TableApi(), {
+    ...getTable(table2),
+    alias: alias2
+  });
+  return {
+    [internalTable]: api,
+    [internalTarget]: api.target(),
+    ...api.fields()
+  };
+}
+export {
+  TableApi,
+  alias,
+  table
+};

package/dist/core/Types.d.ts

@@ -0,0 +1,3 @@
+export type Expand<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/core/Virtual.d.ts

@@ -0,0 +1,2 @@
+import type { SelectionInput } from './Selection.ts';
+export declare function virtual<Input extends SelectionInput>(alias: string, source?: Input): Input;

package/dist/core/Virtual.js

@@ -0,0 +1,28 @@
+import { getSql, hasSql } from "./Internal.ts";
+import { Field } from "./expr/Field.ts";
+function virtual(alias, source) {
+  if (source && hasSql(source)) {
+    const expr = getSql(source);
+    const name = expr.alias;
+    if (!name)
+      throw new Error("Cannot alias a virtual field without a name");
+    return new Field(alias, name, expr);
+  }
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(target, field) {
+      if (field in target)
+        return target[field];
+      const from = source?.[field];
+      if (typeof field !== "string")
+        return from;
+      return target[field] = new Field(
+        alias,
+        field,
+        from ? getSql(from) : void 0
+      );
+    }
+  });
+}
+export {
+  virtual
+};

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

@@ -0,0 +1,10 @@
+import { type HasSql } from '../Internal.ts';
+import { type Sql } from '../Sql.ts';
+export declare function count(input?: HasSql): Sql<number>;
+export declare function countDistinct(input: HasSql): Sql<number>;
+export declare function avg(input: HasSql): Sql<string | null>;
+export declare function avgDistinct(input: HasSql): Sql<string | null>;
+export declare function sum(input: HasSql): HasSql<string | null>;
+export declare function sumDistinct(input: HasSql): HasSql<string | null>;
+export declare function max<T>(input: HasSql<T>): Sql<T>;
+export declare function min<T>(input: HasSql<T>): Sql<T>;

package/dist/core/expr/Aggregate.js

@@ -0,0 +1,38 @@
+import { getSql } from "../Internal.ts";
+import { sql } from "../Sql.ts";
+import { distinct } from "./Conditions.ts";
+import { Functions } from "./Functions.ts";
+function count(input) {
+  return Functions.count(input ?? sql`*`).mapWith(Number);
+}
+function countDistinct(input) {
+  return Functions.count(distinct(input)).mapWith(Number);
+}
+function avg(input) {
+  return Functions.avg(input).mapWith(String);
+}
+function avgDistinct(input) {
+  return Functions.avg(distinct(input)).mapWith(String);
+}
+function sum(input) {
+  return Functions.sum(input).mapWith(String);
+}
+function sumDistinct(input) {
+  return Functions.sum(distinct(input)).mapWith(String);
+}
+function max(input) {
+  return Functions.max(input).mapWith(getSql(input));
+}
+function min(input) {
+  return Functions.min(input).mapWith(getSql(input));
+}
+export {
+  avg,
+  avgDistinct,
+  count,
+  countDistinct,
+  max,
+  min,
+  sum,
+  sumDistinct
+};

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

@@ -0,0 +1,40 @@
+import type { HasSql } from '../Internal.ts';
+import { type Sql } from '../Sql.ts';
+import { type Input } from './Input.ts';
+export declare function eq<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function ne<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function and(...conditions: Array<Input<boolean>>): HasSql<boolean>;
+export declare function or(...conditions: Array<Input<boolean>>): HasSql<boolean>;
+export declare function not(condition: Input): HasSql<boolean>;
+export declare function gt<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function gte<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function lt<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function lte<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function inArray<T>(left: Input<T>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function notInArray<T>(left: Input<T>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function isNull(value: Input): HasSql<boolean>;
+export declare function isNotNull(value: Input): HasSql<boolean>;
+export declare function between<T>(value: Input<T>, left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function notBetween<T>(value: Input<T>, left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function like(left: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function notLike(value: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function ilike(value: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function notILike(value: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function arrayContains<T>(left: Input<Array<T>>, right: Input<T>): HasSql<boolean>;
+export declare function arrayContained<T>(left: Input<T>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function arrayOverlaps<T>(left: Input<Array<T>>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function asc<T>(input: HasSql<T>): Sql;
+export declare function desc<T>(input: HasSql<T>): Sql;
+export declare function distinct<T>(input: HasSql<T>): Sql;
+export interface JsonArrayHasSql<Value> extends HasSql<Value> {
+    [index: number]: JsonExpr<Value>;
+}
+export type JsonRecordHasSql<Row> = HasSql<Row> & {
+    [K in keyof Row]: JsonExpr<Row[K]>;
+};
+type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+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 ? Nullable<Value> : Value> : HasSql<Value>;
+export declare function jsonExpr<Value>(e: HasSql<Value>): JsonExpr<Value>;
+export {};