rado 1.0.0-preview.0 → 1.0.0-preview.2

package/dist/core/Builder.d.ts

@@ -1,14 +1,14 @@
-import { internalData, type HasQuery, type HasSql, type HasTable, type HasTarget } from './Internal.ts';
-import type { IsPostgres, QueryMeta } from './MetaData.ts';
-import type { QueryData } from './Query.ts';
-import type { SelectionInput } from './Selection.ts';
-import type { Table, TableDefinition } from './Table.ts';
-import { Create } from './query/CreateTable.ts';
-import { DeleteFrom } from './query/Delete.ts';
-import { Drop } from './query/DropTable.ts';
-import { InsertInto } from './query/Insert.ts';
-import type { SelectBase, WithSelection, WithoutSelection } from './query/Select.ts';
-import { UpdateTable } from './query/Update.ts';
+import { internalData, type HasQuery, type HasSql, type HasTable, type HasTarget } from './Internal.js';
+import type { IsPostgres, QueryMeta } from './MetaData.js';
+import type { QueryData } from './Query.js';
+import type { SelectionInput } from './Selection.js';
+import type { Table, TableDefinition } from './Table.js';
+import { Create } from './query/CreateTable.js';
+import { DeleteFrom } from './query/Delete.js';
+import { Drop } from './query/DropTable.js';
+import { InsertInto } from './query/Insert.js';
+import type { SelectBase, WithSelection, WithoutSelection } from './query/Select.js';
+import { UpdateTable } from './query/Update.js';
 declare class BuilderBase<Meta extends QueryMeta> {
     readonly [internalData]: QueryData<Meta>;
     constructor(data: QueryData<Meta>);

package/dist/core/Builder.js

@@ -1,3 +1,4 @@
+// src/core/Builder.ts
 import {
   getData,
   getQuery,
@@ -5,15 +6,15 @@ import {
   internalData,
   internalQuery,
   internalTarget
-} from "./Internal.ts";
-import { sql } from "./Sql.ts";
-import { Create } from "./query/CreateTable.ts";
-import { DeleteFrom } from "./query/Delete.ts";
-import { Drop } from "./query/DropTable.ts";
-import { InsertInto } from "./query/Insert.ts";
-import { Select } from "./query/Select.ts";
-import { UpdateTable } from "./query/Update.ts";
-class BuilderBase {
+} from "./Internal.js";
+import { sql } from "./Sql.js";
+import { Create } from "./query/CreateTable.js";
+import { DeleteFrom } from "./query/Delete.js";
+import { Drop } from "./query/DropTable.js";
+import { InsertInto } from "./query/Insert.js";
+import { Select } from "./query/Select.js";
+import { UpdateTable } from "./query/Update.js";
+var BuilderBase = class {
   [internalData];
   constructor(data) {
     this[internalData] = data;
@@ -68,8 +69,8 @@ class BuilderBase {
   delete(from) {
     return new DeleteFrom({ ...getData(this), from });
   }
-}
-class Builder extends BuilderBase {
+};
+var Builder = class extends BuilderBase {
   $with(cteName) {
     return {
       as(query) {
@@ -93,7 +94,7 @@ class Builder extends BuilderBase {
   dropTable(table) {
     return new Drop({ ...getData(this), table });
   }
-}
+};
 export {
   Builder
 };

package/dist/core/Column.d.ts

@@ -1,8 +1,8 @@
-import type { HasColumn, HasSql } from './Internal.ts';
-import { internalColumn } from './Internal.ts';
-import type { Sql } from './Sql.ts';
-import type { Field, FieldData } from './expr/Field.ts';
-import { type Input } from './expr/Input.ts';
+import type { HasColumn, HasSql } from './Internal.js';
+import { internalColumn } from './Internal.js';
+import type { Sql } from './Sql.js';
+import type { Field, FieldData } from './expr/Field.js';
+import { type Input } from './expr/Input.js';
 export declare class ColumnData {
     type: Sql;
     name?: string;

package/dist/core/Column.js

@@ -1,6 +1,7 @@
-import { getField, internalColumn } from "./Internal.ts";
-import { input } from "./expr/Input.ts";
-class ColumnData {
+// src/core/Column.ts
+import { getField, internalColumn } from "./Internal.js";
+import { input } from "./expr/Input.js";
+var ColumnData = class {
   type;
   name;
   json;
@@ -10,20 +11,20 @@ class ColumnData {
   autoIncrement;
   onUpdate;
   onDelete;
-}
-class Column {
+};
+var Column = class _Column {
   [internalColumn];
   constructor(data) {
     this[internalColumn] = data;
   }
   notNull() {
-    return new Column({
+    return new _Column({
       ...this[internalColumn],
       notNull: true
     });
   }
   default(value) {
-    return new Column({
+    return new _Column({
       ...this[internalColumn],
       defaultValue() {
         return input(value instanceof Function ? value() : value);
@@ -31,13 +32,13 @@ class Column {
     });
   }
   primaryKey() {
-    return new Column({ ...this[internalColumn], primary: true });
+    return new _Column({ ...this[internalColumn], primary: true });
   }
   unique(name) {
-    return new Column({ ...this[internalColumn], isUnique: true });
+    return new _Column({ ...this[internalColumn], isUnique: true });
   }
   references(foreignField) {
-    return new Column({
+    return new _Column({
       ...this[internalColumn],
       references() {
         return getField(
@@ -46,12 +47,12 @@ class Column {
       }
     });
   }
-}
-class JsonColumn extends Column {
+};
+var JsonColumn = class extends Column {
   constructor(data) {
     super({ ...data, json: true });
   }
-}
+};
 export {
   Column,
   ColumnData,

package/dist/core/Constraint.d.ts

@@ -1,5 +1,5 @@
-import { internalConstraint, internalData, type HasConstraint, type HasData } from './Internal.ts';
-import type { Field, FieldData } from './expr/Field.ts';
+import { internalConstraint, internalData, type HasConstraint, type HasData } from './Internal.js';
+import type { Field, FieldData } from './expr/Field.js';
 export interface UniqueConstraintData {
     fields: Array<FieldData>;
     nullsNotDistinct?: boolean;

package/dist/core/Constraint.js

@@ -1,21 +1,22 @@
+// src/core/Constraint.ts
 import {
   getData,
   getField,
   internalConstraint,
   internalData
-} from "./Internal.ts";
-import { sql } from "./Sql.ts";
-class UniqueConstraint {
+} from "./Internal.js";
+import { sql } from "./Sql.js";
+var UniqueConstraint = class _UniqueConstraint {
   [internalData];
   constructor(data) {
     this[internalData] = data;
   }
   on(...columns) {
     const fields = columns.map(getField);
-    return new UniqueConstraint({ ...getData(this), fields });
+    return new _UniqueConstraint({ ...getData(this), fields });
   }
   nullsNotDistinct() {
-    return new UniqueConstraint({ ...getData(this), nullsNotDistinct: true });
+    return new _UniqueConstraint({ ...getData(this), nullsNotDistinct: true });
   }
   get [internalConstraint]() {
     const { fields, nullsNotDistinct } = getData(this);
@@ -28,11 +29,11 @@ class UniqueConstraint {
       )})`
     ]);
   }
-}
+};
 function unique() {
   return new UniqueConstraint({ fields: [] });
 }
-class PrimaryKeyConstraint {
+var PrimaryKeyConstraint = class {
   constructor(data) {
     this.data = data;
     this[internalData] = data;
@@ -45,17 +46,17 @@ class PrimaryKeyConstraint {
       sql`, `
     )})`;
   }
-}
+};
 function primaryKey(...fields) {
   return new PrimaryKeyConstraint({ fields: fields.map(getField) });
 }
-class ForeignKeyConstraint {
+var ForeignKeyConstraint = class _ForeignKeyConstraint {
   [internalData];
   constructor(data) {
     this[internalData] = data;
   }
   references(...fields) {
-    return new ForeignKeyConstraint({
+    return new _ForeignKeyConstraint({
       ...getData(this),
       references: fields.map(getField)
     });
@@ -70,7 +71,7 @@ class ForeignKeyConstraint {
       sql`, `
     )})`;
   }
-}
+};
 function foreignKey(...fields) {
   return new ForeignKeyConstraint({
     fields: fields.map(getField),

package/dist/core/Database.d.ts

@@ -1,9 +1,9 @@
-import { Builder } from './Builder.ts';
-import type { Dialect } from './Dialect.ts';
-import type { Driver } from './Driver.ts';
-import { internalResolver, type HasResolver } from './Internal.ts';
-import type { Async, Either, QueryDialect, QueryMeta, Sync } from './MetaData.ts';
-import { Resolver } from './Resolver.ts';
+import { Builder } from './Builder.js';
+import type { Dialect } from './Dialect.js';
+import type { Driver } from './Driver.js';
+import { internalResolver, type HasResolver } from './Internal.js';
+import type { Async, Either, QueryDialect, QueryMeta, Sync } from './MetaData.js';
+import { Resolver } from './Resolver.js';
 export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
     #private;
     readonly [internalResolver]: Resolver<Meta>;

package/dist/core/Database.js

@@ -1,7 +1,8 @@
-import { Builder } from "./Builder.ts";
-import { internalResolver } from "./Internal.ts";
-import { Resolver } from "./Resolver.ts";
-class Database extends Builder {
+// src/core/Database.ts
+import { Builder } from "./Builder.js";
+import { internalResolver } from "./Internal.js";
+import { Resolver } from "./Resolver.js";
+var Database = class extends Builder {
   [internalResolver];
   #driver;
   #dialect;
@@ -37,18 +38,18 @@ class Database extends Builder {
       this.#transactionDepth
     );
   }
-}
-class Rollback extends Error {
-}
-class Transaction extends Database {
+};
+var Rollback = class extends Error {
+};
+var Transaction = class extends Database {
   rollback() {
     throw new Rollback("Rollback");
   }
-}
-class SyncDatabase extends Database {
-}
-class AsyncDatabase extends Database {
-}
+};
+var SyncDatabase = class extends Database {
+};
+var AsyncDatabase = class extends Database {
+};
 export {
   AsyncDatabase,
   Database,

package/dist/core/Dialect.d.ts

@@ -1,5 +1,5 @@
-import type { Emitter } from './Emitter.ts';
-import { type HasQuery, type HasSql } from './Internal.ts';
+import type { Emitter } from './Emitter.js';
+import { type HasQuery, type HasSql } from './Internal.js';
 export declare function dialect(createEmitter: {
     new (): Emitter;
 }): (input: HasSql | HasQuery) => Emitter;

package/dist/core/Dialect.js

@@ -1,8 +1,9 @@
+// src/core/Dialect.ts
 import {
   getQuery,
   getSql,
   hasSql
-} from "./Internal.ts";
+} from "./Internal.js";
 function dialect(createEmitter) {
   return (input) => {
     const sql = hasSql(input) ? getSql(input) : getQuery(input);

package/dist/core/Emitter.d.ts

@@ -1,14 +1,14 @@
-import type { ColumnData } from './Column.ts';
-import { type HasQuery, type HasTarget } from './Internal.ts';
-import { type Param } from './Param.ts';
-import type { FieldData } from './expr/Field.ts';
-import type { Create } from './query/CreateTable.ts';
-import type { Delete } from './query/Delete.ts';
-import type { Drop } from './query/DropTable.ts';
-import type { Insert } from './query/Insert.ts';
-import type { Select } from './query/Select.ts';
-import type { Union } from './query/Union.ts';
-import type { Update } from './query/Update.ts';
+import type { ColumnData } from './Column.js';
+import { type HasQuery, type HasTarget } from './Internal.js';
+import { type Param } from './Param.js';
+import type { FieldData } from './expr/Field.js';
+import type { Create } from './query/CreateTable.js';
+import type { Delete } from './query/Delete.js';
+import type { Drop } from './query/DropTable.js';
+import type { Insert } from './query/Insert.js';
+import type { Select } from './query/Select.js';
+import type { Union } from './query/Union.js';
+import type { Update } from './query/Update.js';
 export declare abstract class Emitter {
     sql: string;
     params: Array<Param>;

package/dist/core/Emitter.js

@@ -1,13 +1,14 @@
+// src/core/Emitter.ts
 import {
   getData,
   getQuery,
   getSelection,
   getTable,
   getTarget
-} from "./Internal.ts";
-import { ValueParam } from "./Param.ts";
-import { sql } from "./Sql.ts";
-class Emitter {
+} from "./Internal.js";
+import { ValueParam } from "./Param.js";
+import { sql } from "./Sql.js";
+var Emitter = class {
   sql = "";
   params = [];
   bind(inputs) {
@@ -147,7 +148,7 @@ class Emitter {
       )
     }).add(sql` `).emit(this);
   }
-}
+};
 export {
   Emitter
 };

package/dist/core/Index.d.ts

@@ -1,5 +1,5 @@
-import { internalData, type HasData, type HasSql } from './Internal.ts';
-import type { Field, FieldData } from './expr/Field.ts';
+import { internalData, type HasData, type HasSql } from './Internal.js';
+import type { Field, FieldData } from './expr/Field.js';
 export interface IndexData {
     fields: Array<FieldData>;
     unique?: boolean;

package/dist/core/Index.js

@@ -1,42 +1,43 @@
+// src/core/Index.ts
 import {
   getData,
   getField,
   internalData
-} from "./Internal.ts";
-class Index {
+} from "./Internal.js";
+var Index = class _Index {
   [internalData];
   constructor(data) {
     this[internalData] = data;
   }
   on(...columns) {
     const fields = columns.map(getField);
-    return new Index({ ...getData(this), fields });
+    return new _Index({ ...getData(this), fields });
   }
   concurrently() {
-    return new Index({ ...getData(this), concurrently: true });
+    return new _Index({ ...getData(this), concurrently: true });
   }
   only() {
-    return new Index({ ...getData(this), only: true });
+    return new _Index({ ...getData(this), only: true });
   }
   using(using) {
-    return new Index({ ...getData(this), using });
+    return new _Index({ ...getData(this), using });
   }
   asc() {
-    return new Index({ ...getData(this), order: "asc" });
+    return new _Index({ ...getData(this), order: "asc" });
   }
   desc() {
-    return new Index({ ...getData(this), order: "desc" });
+    return new _Index({ ...getData(this), order: "desc" });
   }
   nullsFirst() {
-    return new Index({ ...getData(this), nulls: "first" });
+    return new _Index({ ...getData(this), nulls: "first" });
   }
   nullsLast() {
-    return new Index({ ...getData(this), nulls: "last" });
+    return new _Index({ ...getData(this), nulls: "last" });
   }
   where(where) {
-    return new Index({ ...getData(this), where });
+    return new _Index({ ...getData(this), where });
   }
-}
+};
 function index() {
   return new Index({ fields: [] });
 }

package/dist/core/Internal.d.ts

@@ -1,10 +1,10 @@
-import type { ColumnData } from './Column.ts';
-import type { QueryMeta } from './MetaData.ts';
-import type { Resolver } from './Resolver.ts';
-import type { Selection } from './Selection.ts';
-import type { Sql } from './Sql.ts';
-import type { TableApi, TableDefinition } from './Table.ts';
-import type { FieldData } from './expr/Field.ts';
+import type { ColumnData } from './Column.js';
+import type { QueryMeta } from './MetaData.js';
+import type { Resolver } from './Resolver.js';
+import type { Selection } from './Selection.js';
+import type { Sql } from './Sql.js';
+import type { TableApi, TableDefinition } from './Table.js';
+import type { FieldData } from './expr/Field.js';
 export declare const internalData: unique symbol;
 export declare const internalSql: unique symbol;
 export declare const internalSelection: unique symbol;

package/dist/core/Internal.js

@@ -1,33 +1,34 @@
-const internalData = Symbol();
-const internalSql = Symbol();
-const internalSelection = Symbol();
-const internalTarget = Symbol();
-const internalQuery = Symbol();
-const internalTable = Symbol();
-const internalColumn = Symbol();
-const internalField = Symbol();
-const internalResolver = Symbol();
-const internalConstraint = Symbol();
-const hasData = (obj) => internalData in obj;
-const getData = (obj) => obj[internalData];
-const hasSql = (obj) => internalSql in obj;
-const getSql = (obj) => obj[internalSql];
-const hasSelection = (obj) => internalSelection in obj;
-const getSelection = (obj) => obj[internalSelection];
-const hasTarget = (obj) => internalTarget in obj;
-const getTarget = (obj) => obj[internalTarget];
-const hasQuery = (obj) => internalQuery in obj;
-const getQuery = (obj) => obj[internalQuery];
-const hasTable = (obj) => internalTable in obj;
-const getTable = (obj) => obj[internalTable];
-const hasColumn = (obj) => internalColumn in obj;
-const getColumn = (obj) => obj[internalColumn];
-const hasField = (obj) => internalField in obj;
-const getField = (obj) => obj[internalField];
-const hasResolver = (obj) => internalResolver in obj;
-const getResolver = (obj) => obj[internalResolver];
-const hasConstraint = (obj) => internalConstraint in obj;
-const getConstraint = (obj) => obj[internalConstraint];
+// src/core/Internal.ts
+var internalData = Symbol();
+var internalSql = Symbol();
+var internalSelection = Symbol();
+var internalTarget = Symbol();
+var internalQuery = Symbol();
+var internalTable = Symbol();
+var internalColumn = Symbol();
+var internalField = Symbol();
+var internalResolver = Symbol();
+var internalConstraint = Symbol();
+var hasData = (obj) => internalData in obj;
+var getData = (obj) => obj[internalData];
+var hasSql = (obj) => internalSql in obj;
+var getSql = (obj) => obj[internalSql];
+var hasSelection = (obj) => internalSelection in obj;
+var getSelection = (obj) => obj[internalSelection];
+var hasTarget = (obj) => internalTarget in obj;
+var getTarget = (obj) => obj[internalTarget];
+var hasQuery = (obj) => internalQuery in obj;
+var getQuery = (obj) => obj[internalQuery];
+var hasTable = (obj) => internalTable in obj;
+var getTable = (obj) => obj[internalTable];
+var hasColumn = (obj) => internalColumn in obj;
+var getColumn = (obj) => obj[internalColumn];
+var hasField = (obj) => internalField in obj;
+var getField = (obj) => obj[internalField];
+var hasResolver = (obj) => internalResolver in obj;
+var getResolver = (obj) => obj[internalResolver];
+var hasConstraint = (obj) => internalConstraint in obj;
+var getConstraint = (obj) => obj[internalConstraint];
 export {
   getColumn,
   getConstraint,

package/dist/core/Param.js

@@ -1,13 +1,14 @@
-class NamedParam {
+// src/core/Param.ts
+var NamedParam = class {
   constructor(name) {
     this.name = name;
   }
-}
-class ValueParam {
+};
+var ValueParam = class {
   constructor(value) {
     this.value = value;
   }
-}
+};
 export {
   NamedParam,
   ValueParam

package/dist/core/Query.d.ts

@@ -1,7 +1,7 @@
-import { internalData, internalQuery, type HasQuery, type HasResolver, type HasTarget } from './Internal.ts';
-import type { Async, QueryMeta, Sync } from './MetaData.ts';
-import type { PreparedStatement, Resolver } from './Resolver.ts';
-import type { Sql } from './Sql.ts';
+import { internalData, internalQuery, type HasQuery, type HasResolver, type HasTarget } from './Internal.js';
+import type { Async, QueryMeta, Sync } from './MetaData.js';
+import type { PreparedStatement, Resolver } from './Resolver.js';
+import type { Sql } from './Sql.js';
 export declare class QueryData<Meta extends QueryMeta> {
     resolver?: Resolver<Meta>;
     cte?: Array<HasQuery & HasTarget>;

package/dist/core/Query.js

@@ -1,15 +1,16 @@
+// src/core/Query.ts
 import {
   getData,
   getResolver,
   hasResolver,
   hasSelection,
   internalData
-} from "./Internal.ts";
-class QueryData {
+} from "./Internal.js";
+var QueryData = class {
   resolver;
   cte;
-}
-class Query {
+};
+var Query = class {
   [internalData];
   constructor(data) {
     this[internalData] = data;
@@ -63,7 +64,7 @@ class Query {
   finally(onfinally) {
     return this.#exec(void 0).finally(onfinally);
   }
-}
+};
 export {
   Query,
   QueryData

package/dist/core/Resolver.d.ts

@@ -1,8 +1,8 @@
-import type { Dialect } from './Dialect.ts';
-import type { Driver, Statement } from './Driver.ts';
-import type { Emitter } from './Emitter.ts';
-import { type HasQuery } from './Internal.ts';
-import type { QueryMeta } from './MetaData.ts';
+import type { Dialect } from './Dialect.js';
+import type { Driver, Statement } from './Driver.js';
+import type { Emitter } from './Emitter.js';
+import { type HasQuery } from './Internal.js';
+import type { QueryMeta } from './MetaData.js';
 export declare class Resolver<Meta extends QueryMeta = QueryMeta> {
     #private;
     private brand;

package/dist/core/Resolver.js

@@ -1,5 +1,6 @@
-import { getSelection, hasSelection } from "./Internal.ts";
-class Resolver {
+// src/core/Resolver.ts
+import { getSelection, hasSelection } from "./Internal.js";
+var Resolver = class {
   #driver;
   #dialect;
   constructor(driver, dialect) {
@@ -13,8 +14,8 @@ class Resolver {
     const stmt = this.#driver.prepare(emitter.sql, name);
     return new PreparedStatement(emitter, stmt, mapRow);
   }
-}
-class PreparedStatement {
+};
+var PreparedStatement = class {
   #emitter;
   #stmt;
   #mapRow;
@@ -47,7 +48,7 @@ class PreparedStatement {
   free() {
     this.#stmt.free();
   }
-}
+};
 export {
   PreparedStatement,
   Resolver

package/dist/core/Schema.d.ts

@@ -1,4 +1,4 @@
-import { type Table, type TableConfig, type TableDefinition } from './Table.ts';
+import { type Table, type TableConfig, type TableDefinition } from './Table.js';
 export declare function schema<SchemaName extends string>(schemaName: SchemaName): {
     table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: ((self: Table<Definition>) => TableConfig<`${SchemaName}.${TableName}`>) | undefined): Table<Definition, `${SchemaName}.${TableName}`>;
 };

package/dist/core/Schema.js

@@ -1,6 +1,7 @@
+// src/core/Schema.ts
 import {
   table
-} from "./Table.ts";
+} from "./Table.js";
 function schema(schemaName) {
   return {
     table(tableName, columns, config) {