rado 1.2.1 → 1.3.0-preview.0

package/dist/core/Selection.js

@@ -1,19 +1,23 @@
 // src/core/Selection.ts
 import {
   getField,
+  getSelection,
   getSql,
   getTable,
   hasField,
+  hasSelection,
   hasTable,
   internalSql
 } from "./Internal.js";
 import { sql } from "./Sql.js";
-import { virtual } from "./Virtual.js";
+import { virtualTarget } from "./Virtual.js";
 var SqlColumn = class {
   constructor(sql2, targetName) {
     this.sql = sql2;
     this.targetName = targetName;
   }
+  sql;
+  targetName;
   result(ctx) {
     const value = ctx.values[ctx.index++];
     if (!this.sql.mapFromDriverValue) return value;
@@ -25,6 +29,8 @@ var ObjectColumn = class {
     this.nullable = nullable;
     this.entries = entries;
   }
+  nullable;
+  entries;
   result(ctx) {
     const result = {};
     let isNullable = this.nullable.size > 0;
@@ -46,16 +52,27 @@ var ObjectColumn = class {
     return result;
   }
 };
-var Selection = class {
+function firstTargetName(input) {
+  const expr = getSql(input);
+  if (expr) return hasField(input) ? getField(input).targetName : void 0;
+  if (!input || typeof input !== "object") return;
+  for (const value of Object.values(input)) {
+    const name = firstTargetName(value);
+    if (name) return name;
+  }
+}
+var Selection = class _Selection {
   constructor(input, nullable = /* @__PURE__ */ new Set()) {
     this.input = input;
     this.nullable = nullable;
     const root = this.#defineColumn(nullable, input);
     this.mapRow = root.result.bind(root);
   }
+  input;
+  nullable;
   mapRow;
   makeVirtual(name) {
-    return virtual(name, this.input);
+    return virtualTarget(name, this.input);
   }
   #defineColumn(nullable, input) {
     const expr = getSql(input);
@@ -71,6 +88,24 @@ var Selection = class {
   fieldNames() {
     return this.#fieldNames(this.input, /* @__PURE__ */ new Set());
   }
+  aliasOf(input) {
+    return this.#aliasOf(this.input, /* @__PURE__ */ new Set(), getSql(input));
+  }
+  #aliasOf(input, names, target, name) {
+    const expr = getSql(input);
+    if (expr) {
+      let exprName = name ?? expr.alias;
+      if (!exprName) return;
+      while (names.has(exprName)) exprName = `${exprName}_`;
+      names.add(exprName);
+      if (expr === target) return exprName;
+      return;
+    }
+    for (const [name2, value] of Object.entries(input)) {
+      const alias = this.#aliasOf(value, names, target, name2);
+      if (alias) return alias;
+    }
+  }
   #fieldNames(input, names, name) {
     const expr = getSql(input);
     if (expr) {
@@ -105,8 +140,40 @@ var Selection = class {
   get [internalSql]() {
     return sql.join(this.#selectionToSql(this.input, /* @__PURE__ */ new Set()), sql`, `);
   }
+  #collectTargetNames(input, names) {
+    const expr = getSql(input);
+    if (expr) {
+      if (hasField(input)) names.add(getField(input).targetName);
+      return;
+    }
+    for (const value of Object.values(input))
+      this.#collectTargetNames(value, names);
+  }
+  #targetNames() {
+    const names = /* @__PURE__ */ new Set();
+    this.#collectTargetNames(this.input, names);
+    return names;
+  }
   join(right, operator) {
-    return this;
+    if (hasSelection(right)) {
+      const selected2 = getSelection(right);
+      const alias = firstTargetName(selected2.input);
+      if (!alias) return this;
+      const nullable2 = new Set(this.nullable);
+      if (operator === "leftJoin" || operator === "fullJoin")
+        nullable2.add(alias);
+      if (operator === "rightJoin" || operator === "fullJoin")
+        for (const name of this.#targetNames()) nullable2.add(name);
+      return new _Selection(this.input, nullable2);
+    }
+    if (!hasTable(right)) return this;
+    const rightTable = getTable(right);
+    const nullable = new Set(this.nullable);
+    if (operator === "leftJoin" || operator === "fullJoin")
+      nullable.add(rightTable.aliased);
+    if (operator === "rightJoin" || operator === "fullJoin")
+      for (const name of this.#targetNames()) nullable.add(name);
+    return new _Selection(this.input, nullable);
   }
 };
 var TableSelection = class extends Selection {
@@ -114,8 +181,23 @@ var TableSelection = class extends Selection {
     super(table, /* @__PURE__ */ new Set());
     this.table = table;
   }
+  table;
   join(right, operator) {
     const leftTable = getTable(this.table);
+    if (hasSelection(right)) {
+      const selected2 = getSelection(right);
+      const alias = firstTargetName(selected2.input);
+      if (!alias) return this;
+      const nullable2 = new Set(this.nullable);
+      if (operator === "rightJoin" || operator === "fullJoin")
+        nullable2.add(leftTable.aliased);
+      if (operator === "leftJoin" || operator === "fullJoin")
+        nullable2.add(alias);
+      return new Selection(
+        { [leftTable.aliased]: this.table, [alias]: selected2.input },
+        nullable2
+      );
+    }
     if (!hasTable(right)) return this;
     const rightTable = getTable(right);
     const nullable = new Set(this.nullable);
@@ -134,17 +216,23 @@ var JoinSelection = class _JoinSelection extends Selection {
     );
     this.tables = tables;
   }
+  tables;
   join(right, operator) {
     if (!hasTable(right)) return this;
     const rightTable = getTable(right);
     const nullable = new Set(this.nullable);
     if (operator === "rightJoin" || operator === "fullJoin")
-      this.tables.map((table) => getTable(table).aliased).forEach(nullable.add, nullable);
+      for (const table of this.tables) nullable.add(getTable(table).aliased);
     if (operator === "leftJoin" || operator === "fullJoin")
       nullable.add(rightTable.aliased);
     return new _JoinSelection([...this.tables, right], nullable);
   }
 };
+var StarSelection = class extends Selection {
+  get [internalSql]() {
+    return sql`*`;
+  }
+};
 var selected = /* @__PURE__ */ new WeakMap();
 function selection(input) {
   if (input instanceof Selection) return input;
@@ -156,6 +244,7 @@ function selection(input) {
 export {
   JoinSelection,
   Selection,
+  StarSelection,
   TableSelection,
   selection
 };

package/dist/core/Sql.d.ts

@@ -1,9 +1,9 @@
 import type { DriverSpecs } from './Driver.js';
 import type { Emitter } from './Emitter.js';
-import { type HasSql, internalSql } from './Internal.js';
-import type { Runtime } from './MetaData.js';
 import type { FieldData } from './expr/Field.js';
 import type { JsonPath } from './expr/Json.js';
+import { type HasSql, internalSql } from './Internal.js';
+import type { Runtime } from './MetaData.js';
 export type Decoder<T = unknown> = ((value: unknown) => T) | {
     mapFromDriverValue?(value: unknown, specs: DriverSpecs): T;
 };
@@ -14,13 +14,14 @@ export declare class Sql<Value = unknown> implements HasSql<Value> {
     alias?: string;
     mapFromDriverValue?: (input: unknown, specs: DriverSpecs) => Value;
     readonly [internalSql]: this;
-    constructor(emit?: (emitter: Emitter) => void);
+    constructor(emit: (emitter: Emitter) => void);
     as(name: string): Sql<Value>;
     mapWith<T = Value>(decoder: Decoder<T>): Sql<T>;
     inlineFields(withTableName: boolean): Sql<Value>;
     inlineValues(): Sql<Value>;
     nameSelf(name: string): Sql<Value>;
     forSelection(): Sql<Value>;
+    if(condition: unknown): Sql<Value> | undefined;
 }
 export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql | unknown>): Sql<T>;
 export declare namespace sql {

package/dist/core/Sql.js

@@ -9,9 +9,10 @@ import {
 var noop = () => {
 };
 var Sql = class _Sql {
-  constructor(emit = noop) {
+  constructor(emit) {
     this.emit = emit;
   }
+  emit;
   static SELF_TARGET = "$$self";
   alias;
   mapFromDriverValue;
@@ -37,12 +38,16 @@ var Sql = class _Sql {
   forSelection() {
     return this;
   }
+  if(condition) {
+    return condition ? this : void 0;
+  }
 };
 var JsonPathSql = class extends Sql {
   constructor(path) {
     super((emitter) => emitter.emitJsonPath(path));
     this.path = path;
   }
+  path;
   forSelection() {
     return sql.jsonPath({ ...this.path, asSql: false }).mapWith(this);
   }
@@ -53,6 +58,7 @@ function sql(strings, ...inner) {
       emitter.emitUnsafe(strings[i]);
       if (i < inner.length) {
         const insert = inner[i];
+        if (insert === void 0) continue;
         const isObject = insert !== null && typeof insert === "object";
         if (isObject && hasSql(insert)) getSql(insert).emit(emitter);
         else if (isObject && hasTarget(insert)) getTarget(insert).emit(emitter);
@@ -63,7 +69,7 @@ function sql(strings, ...inner) {
 }
 ((sql2) => {
   function empty() {
-    return new Sql();
+    return new Sql(noop);
   }
   sql2.empty = empty;
   function unsafe(directSql) {

package/dist/core/Table.d.ts

@@ -1,11 +1,11 @@
-import { type Column, type JsonColumn, type RequiredColumn } from './Column.js';
+import { type Column, type JsonColumn } from './Column.js';
 import type { ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from './Constraint.js';
-import { Index } from './Index.js';
-import { type HasSelection, type HasSql, type HasTable } from './Internal.js';
-import { type Sql } from './Sql.js';
 import { Field } from './expr/Field.js';
 import type { Input } from './expr/Input.js';
 import { type JsonExpr } from './expr/Json.js';
+import { Index } from './Index.js';
+import { type HasCreate, type HasDrop, type HasSelection, type HasSql, type HasTable } from './Internal.js';
+import { type Sql } from './Sql.js';
 export type TableDefinition = {
     [name: string]: Column;
 };
@@ -24,30 +24,37 @@ export declare class TableApi<Definition extends TableDefinition = TableDefiniti
     columnDefinition(name: string): Sql;
     createDefinition(): Sql;
     listColumns(): Sql;
-    fields(): Record<string, HasSql>;
     createTable(altName?: string, ifNotExists?: boolean): Sql;
     createIndexes(): Array<Sql>;
+    createEnums(): Array<Sql>;
     create(): Array<Sql>;
-    drop(): Sql;
+    drop(): Array<Sql>;
     indexes(): Record<string, Index>;
 }
-export type Table<Definition extends TableDefinition = Record<never, Column>, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasSelection;
+export declare function tableFields(targetName: string, columns: TableDefinition): Record<string, HasSql>;
+export type Table<Definition extends TableDefinition = Record<never, Column>, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasSelection & HasCreate & HasDrop;
 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;
+    [K in keyof Definition]: Definition[K] extends JsonColumn<infer T> ? JsonExpr<T> : Definition[K] extends Column<infer T, [
+        infer Nullable extends boolean,
+        boolean
+    ]> ? [Nullable] extends [false] ? Field<T, TableName> : Field<T | null, 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<infer Value> ? null extends Value ? true : false : false;
+type IsReq<Col> = Col extends Column<unknown, [boolean, infer Required extends boolean]> ? [Required] extends [true] ? true : false : false;
 type RequiredInput<D> = {
     readonly [K in keyof D as true extends IsReq<D[K]> ? K : never]: D[K] extends Column<infer V> ? Input<V> : never;
 };
 type OptionalInput<D> = {
-    readonly [K in keyof D as false extends IsReq<D[K]> ? K : never]?: D[K] extends Column<infer V> ? Input<V> : never;
+    readonly [K in keyof D as false extends IsReq<D[K]> ? K : never]?: D[K] extends Column<infer V> ? Input<V | null> : 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;
+    readonly [K in keyof Definition]?: Definition[K] extends Column<infer T, [
+        infer Nullable extends boolean,
+        boolean
+    ]> ? Nullable extends false ? Input<T> : Input<T | null> : 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>> {

package/dist/core/Table.js

@@ -1,21 +1,24 @@
 // src/core/Table.ts
-import {
-  formatColumn
-} from "./Column.js";
+import { collectEnumQuery } from "../postgres/enum.js";
+import { formatColumn } from "./Column.js";
+import { Field } from "./expr/Field.js";
+import { jsonExpr } from "./expr/Json.js";
 import { Index } from "./Index.js";
 import {
   getConstraint,
+  getCreate,
   getData,
+  getDrop,
   getTable,
   hasConstraint,
+  internalCreate,
+  internalDrop,
   internalSelection,
   internalTable,
   internalTarget
 } from "./Internal.js";
 import { selection } from "./Selection.js";
 import { sql } from "./Sql.js";
-import { Field } from "./expr/Field.js";
-import { jsonExpr } from "./expr/Json.js";
 var { assign, fromEntries, entries, keys } = Object;
 var TableData = class {
   name;
@@ -71,17 +74,6 @@ var TableApi = class extends TableData {
       sql`, `
     );
   }
-  fields() {
-    return fromEntries(
-      entries(this.columns).map(([name, column]) => {
-        const columnApi = getData(column);
-        const { name: givenName } = columnApi;
-        const field = new Field(this.aliased, givenName ?? name, columnApi);
-        if (columnApi.json) return [name, jsonExpr(field)];
-        return [name, field];
-      })
-    );
-  }
   createTable(altName, ifNotExists = false) {
     return sql.join([
       sql`create table`,
@@ -96,11 +88,14 @@ var TableApi = class extends TableData {
       return indexApi.toSql(this.name, name, false);
     });
   }
+  createEnums() {
+    return collectEnumQuery(this);
+  }
   create() {
-    return [this.createTable(), ...this.createIndexes()];
+    return [...this.createEnums(), this.createTable(), ...this.createIndexes()];
   }
   drop() {
-    return sql`drop table if exists ${this.target()}`;
+    return [sql`drop table if exists ${this.identifier()}`];
   }
   indexes() {
     return fromEntries(
@@ -108,17 +103,34 @@ var TableApi = class extends TableData {
     );
   }
 };
+function tableFields(targetName, columns) {
+  return fromEntries(
+    entries(columns).map(([name, column]) => {
+      const columnApi = getData(column);
+      const { name: givenName } = columnApi;
+      const field = new Field(targetName, 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 fields = api.fields();
+  const fields = tableFields(api.aliased, api.columns);
   const table2 = {
     [internalTable]: api,
-    [internalTarget]: api.target(),
+    [internalTarget]: api.identifier(),
     [internalSelection]: selection(fields),
+    get [internalCreate]() {
+      return api.create();
+    },
+    get [internalDrop]() {
+      return api.drop();
+    },
     ...fields
   };
   if (config) api.config = config(table2);
@@ -129,22 +141,30 @@ function alias(table2, alias2) {
     ...getTable(table2),
     alias: alias2
   });
-  const fields = api.fields();
+  const fields = tableFields(api.aliased, api.columns);
   return {
     [internalTable]: api,
-    [internalTarget]: api.target(),
+    [internalTarget]: api.identifier(),
     [internalSelection]: selection(fields),
-    ...api.fields()
+    get [internalCreate]() {
+      return getCreate(table2);
+    },
+    get [internalDrop]() {
+      return getDrop(table2);
+    },
+    ...fields
   };
 }
 function tableCreator(nameTable) {
   return (name, columns, config, schemaName) => {
-    return table(nameTable(name), columns, config, schemaName);
+    const created = table(nameTable(name), columns, config, schemaName);
+    return alias(created, name);
   };
 }
 export {
   TableApi,
   alias,
   table,
-  tableCreator
+  tableCreator,
+  tableFields
 };

package/dist/core/View.d.ts

@@ -0,0 +1,34 @@
+import { type HasCreate, type HasDrop, type HasSql, type HasTarget, internalData } from './Internal.js';
+import type { QueryMeta } from './MetaData.js';
+import type { UnionBase } from './query/Select.js';
+import { type Sql } from './Sql.js';
+import { type TableDefinition, type TableFields } from './Table.js';
+import type { VirtualTarget } from './Virtual.js';
+interface ViewData {
+    name: string;
+    columns?: TableDefinition;
+    columnNames?: Array<string>;
+    schemaName?: string;
+    materialized?: boolean;
+    query?: Sql;
+}
+export declare class ViewBase {
+    readonly [internalData]: ViewData;
+    constructor(data: ViewData);
+}
+export interface View extends HasTarget, HasCreate, HasDrop {
+}
+export declare function createView(data: ViewData, as: HasSql): Sql;
+export declare function dropView(data: ViewData): Sql;
+export declare class QueryView extends ViewBase {
+    as<Input, Meta extends QueryMeta>(query: UnionBase<Input, Meta>): View & Input;
+}
+export declare class DefinedView<Definition extends TableDefinition> extends ViewBase {
+    existing(): VirtualTarget<TableFields<Definition>>;
+    as(query: HasSql): View & TableFields<Definition>;
+}
+export declare function view(name: string): QueryView;
+export declare function view<Definition extends TableDefinition>(name: string, columns: Definition, schemaName?: string): DefinedView<Definition>;
+export declare function materializedView(name: string): QueryView;
+export declare function materializedView<Definition extends TableDefinition>(name: string, columns: Definition, schemaName?: string): DefinedView<Definition>;
+export {};

package/dist/core/View.js

@@ -0,0 +1,153 @@
+// src/core/View.ts
+import { Field } from "./expr/Field.js";
+import {
+  getData,
+  getField,
+  getQuery,
+  getSelection,
+  getSql,
+  hasField,
+  hasSql,
+  internalCreate,
+  internalData,
+  internalDrop,
+  internalQuery,
+  internalSelection,
+  internalTarget
+} from "./Internal.js";
+import { selection } from "./Selection.js";
+import { sql } from "./Sql.js";
+import { tableFields } from "./Table.js";
+var ViewBase = class {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+};
+function viewIdentifier({ name, schemaName }) {
+  return schemaName ? sql.join([sql.identifier(schemaName), sql.identifier(name)], sql`.`) : sql.identifier(name);
+}
+function createView(data, as) {
+  const createKeyword = data.materialized ? sql`create materialized view` : sql`create view`;
+  const { columns, columnNames } = data;
+  const columnList = columnNames ? sql.join(
+    columnNames.map((name) => sql.identifier(name)),
+    sql`, `
+  ) : columns ? sql.join(
+    Object.entries(columns).map(([name, column]) => {
+      const columnData = getData(column);
+      return sql.identifier(columnData.name ?? name);
+    }),
+    sql`, `
+  ) : void 0;
+  return sql.join([
+    createKeyword,
+    viewIdentifier(data),
+    columnList ? sql`(${columnList})` : void 0,
+    sql`as`,
+    as
+  ]).inlineValues();
+}
+function viewColumnNames(input) {
+  const expr = getSql(input);
+  if (expr) {
+    if (hasField(input)) return [getField(input).fieldName];
+    if (expr.alias) return [expr.alias];
+    throw new Error("Missing field name");
+  }
+  return Object.entries(input).flatMap(([name, value]) => {
+    const expr2 = getSql(value);
+    if (expr2 && !hasField(value)) return [expr2.alias ?? name];
+    return viewColumnNames(value);
+  });
+}
+function viewFields(alias, source) {
+  return Object.fromEntries(
+    Object.entries(source).map(([key, value]) => {
+      if (value && typeof value === "object" && !hasSql(value))
+        return [key, viewFields(alias, value)];
+      const fieldName = hasField(value) ? getField(value).fieldName : key;
+      return [key, new Field(alias, fieldName, getSql(value))];
+    })
+  );
+}
+function dropView(data) {
+  const dropKeyword = data.materialized ? sql`drop materialized view` : sql`drop view`;
+  return sql.join([dropKeyword, sql`if exists`, viewIdentifier(data)]);
+}
+var QueryView = class extends ViewBase {
+  as(query) {
+    const data = getData(this);
+    const input = getSelection(query).input;
+    const target = {
+      [internalTarget]: viewIdentifier(data),
+      ...viewFields(data.name, input)
+    };
+    const createData = {
+      ...data,
+      columnNames: viewColumnNames(input)
+    };
+    return {
+      ...target,
+      [internalSelection]: selection(target),
+      [internalQuery]: getQuery(query),
+      get [internalCreate]() {
+        const result = createView(createData, getQuery(query));
+        return [result];
+      },
+      get [internalDrop]() {
+        return [dropView(data)];
+      }
+    };
+  }
+};
+var DefinedView = class extends ViewBase {
+  existing() {
+    const data = getData(this);
+    const { name, columns } = data;
+    const fields = tableFields(name, columns);
+    return {
+      [internalTarget]: viewIdentifier(data),
+      ...fields,
+      [internalSelection]: selection(fields)
+    };
+  }
+  as(query) {
+    const data = getData(this);
+    const fields = tableFields(
+      data.name,
+      data.columns
+    );
+    return {
+      [internalTarget]: viewIdentifier(data),
+      ...fields,
+      [internalSelection]: selection(fields),
+      [internalQuery]: getSql(query),
+      get [internalCreate]() {
+        const result = createView(data, query);
+        return [result];
+      },
+      get [internalDrop]() {
+        return [dropView(data)];
+      }
+    };
+  }
+};
+function view(name, columns, schemaName) {
+  if (columns) return new DefinedView({ name, columns, schemaName });
+  return new QueryView({ name, columns, schemaName });
+}
+function materializedView(name, columns, schemaName) {
+  const data = { name, columns, schemaName, materialized: true };
+  if (columns) return new DefinedView(data);
+  return new QueryView(data);
+}
+export {
+  DefinedView,
+  QueryView,
+  ViewBase,
+  createView,
+  dropView,
+  materializedView,
+  view
+};

package/dist/core/Virtual.d.ts

@@ -1,2 +1,7 @@
-import { type HasTarget } from './Internal.js';
-export declare function virtual<Input>(alias: string, source: Input): Input & HasTarget;
+import { type HasQuery, internalTarget } from './Internal.js';
+import { type Sql } from './Sql.js';
+export type VirtualQuery<Input> = VirtualTarget<Input> & HasQuery;
+export type VirtualTarget<Input> = Input & {
+    readonly [internalTarget]: Sql;
+};
+export declare function virtualTarget<Input>(alias: string, source: Input): VirtualTarget<Input>;