drizzle-orm 0.28.3 → 0.28.4

package/pg-core/utils.d.cts

@@ -0,0 +1,52 @@
+import { PgTable } from './table.js';
+import { Table } from '../table.js';
+import { type Check } from './checks.js';
+import type { AnyPgColumn } from './columns/index.js';
+import { type ForeignKey } from './foreign-keys.js';
+import { type Index } from './indexes.js';
+import { type PrimaryKey } from './primary-keys.js';
+import { type UniqueConstraint } from './unique-constraint.js';
+import { type PgMaterializedView, type PgView } from './view.js';
+export declare function getTableConfig<TTable extends PgTable>(table: TTable): {
+    columns: import("./columns/common.js").PgColumn<import("../column.js").ColumnBaseConfig<import("../column-builder.js").ColumnDataType, string>, {}, {}>[];
+    indexes: Index[];
+    foreignKeys: ForeignKey[];
+    checks: Check[];
+    primaryKeys: PrimaryKey[];
+    uniqueConstraints: UniqueConstraint[];
+    name: string;
+    schema: string | undefined;
+};
+export declare function getViewConfig<TName extends string = string, TExisting extends boolean = boolean>(view: PgView<TName, TExisting>): {
+    with?: import("./view.js").ViewWithConfig | undefined;
+    name: TName;
+    originalName: TName;
+    schema: string | undefined;
+    selectedFields: import("../operations.js").SelectedFields<import("../column.js").AnyColumn, Table<import("../table.js").TableConfig<import("../column.js").Column<any, object, object>>>>;
+    isExisting: TExisting;
+    query: TExisting extends true ? undefined : import("../index.js").SQL<unknown>;
+    isAlias: boolean;
+};
+export declare function getMaterializedViewConfig<TName extends string = string, TExisting extends boolean = boolean>(view: PgMaterializedView<TName, TExisting>): {
+    with?: import("./view.js").PgMaterializedViewWithConfig | undefined;
+    using?: string | undefined;
+    tablespace?: string | undefined;
+    withNoData?: boolean | undefined;
+    name: TName;
+    originalName: TName;
+    schema: string | undefined;
+    selectedFields: import("../operations.js").SelectedFields<import("../column.js").AnyColumn, Table<import("../table.js").TableConfig<import("../column.js").Column<any, object, object>>>>;
+    isExisting: TExisting;
+    query: TExisting extends true ? undefined : import("../index.js").SQL<unknown>;
+    isAlias: boolean;
+};
+export declare function parsePgNestedArray(arrayString: string, startFrom?: number): [any[], number];
+export declare function parsePgArray(arrayString: string): any[];
+export declare function makePgArray(array: any[]): string;
+export type ColumnsWithTable<TTableName extends string, TForeignTableName extends string, TColumns extends AnyPgColumn<{
+    tableName: TTableName;
+}>[]> = {
+    [Key in keyof TColumns]: AnyPgColumn<{
+        tableName: TForeignTableName;
+    }>;
+};

package/pg-core/utils.d.mts

@@ -0,0 +1,52 @@
+import { PgTable } from './table.js';
+import { Table } from '../table.js';
+import { type Check } from './checks.js';
+import type { AnyPgColumn } from './columns/index.js';
+import { type ForeignKey } from './foreign-keys.js';
+import { type Index } from './indexes.js';
+import { type PrimaryKey } from './primary-keys.js';
+import { type UniqueConstraint } from './unique-constraint.js';
+import { type PgMaterializedView, type PgView } from './view.js';
+export declare function getTableConfig<TTable extends PgTable>(table: TTable): {
+    columns: import("./columns/common.js").PgColumn<import("../column.js").ColumnBaseConfig<import("../column-builder.js").ColumnDataType, string>, {}, {}>[];
+    indexes: Index[];
+    foreignKeys: ForeignKey[];
+    checks: Check[];
+    primaryKeys: PrimaryKey[];
+    uniqueConstraints: UniqueConstraint[];
+    name: string;
+    schema: string | undefined;
+};
+export declare function getViewConfig<TName extends string = string, TExisting extends boolean = boolean>(view: PgView<TName, TExisting>): {
+    with?: import("./view.js").ViewWithConfig | undefined;
+    name: TName;
+    originalName: TName;
+    schema: string | undefined;
+    selectedFields: import("../operations.js").SelectedFields<import("../column.js").AnyColumn, Table<import("../table.js").TableConfig<import("../column.js").Column<any, object, object>>>>;
+    isExisting: TExisting;
+    query: TExisting extends true ? undefined : import("../index.js").SQL<unknown>;
+    isAlias: boolean;
+};
+export declare function getMaterializedViewConfig<TName extends string = string, TExisting extends boolean = boolean>(view: PgMaterializedView<TName, TExisting>): {
+    with?: import("./view.js").PgMaterializedViewWithConfig | undefined;
+    using?: string | undefined;
+    tablespace?: string | undefined;
+    withNoData?: boolean | undefined;
+    name: TName;
+    originalName: TName;
+    schema: string | undefined;
+    selectedFields: import("../operations.js").SelectedFields<import("../column.js").AnyColumn, Table<import("../table.js").TableConfig<import("../column.js").Column<any, object, object>>>>;
+    isExisting: TExisting;
+    query: TExisting extends true ? undefined : import("../index.js").SQL<unknown>;
+    isAlias: boolean;
+};
+export declare function parsePgNestedArray(arrayString: string, startFrom?: number): [any[], number];
+export declare function parsePgArray(arrayString: string): any[];
+export declare function makePgArray(array: any[]): string;
+export type ColumnsWithTable<TTableName extends string, TForeignTableName extends string, TColumns extends AnyPgColumn<{
+    tableName: TTableName;
+}>[]> = {
+    [Key in keyof TColumns]: AnyPgColumn<{
+        tableName: TForeignTableName;
+    }>;
+};

package/pg-core/utils.d.ts

@@ -1,14 +1,14 @@
-import { PgTable } from './table';
-import { Table } from '../table';
-import { type Check } from './checks';
-import type { AnyPgColumn } from './columns';
-import { type ForeignKey } from './foreign-keys';
-import { type Index } from './indexes';
-import { type PrimaryKey } from './primary-keys';
-import { type UniqueConstraint } from './unique-constraint';
-import { type PgMaterializedView, type PgView } from './view';
+import { PgTable } from './table.js';
+import { Table } from '../table.js';
+import { type Check } from './checks.js';
+import type { AnyPgColumn } from './columns/index.js';
+import { type ForeignKey } from './foreign-keys.js';
+import { type Index } from './indexes.js';
+import { type PrimaryKey } from './primary-keys.js';
+import { type UniqueConstraint } from './unique-constraint.js';
+import { type PgMaterializedView, type PgView } from './view.js';
 export declare function getTableConfig<TTable extends PgTable>(table: TTable): {
-    columns: import("./columns").PgColumn<import("..").ColumnBaseConfig<import("..").ColumnDataType, string>, {}, {}>[];
+    columns: import("./columns/common.js").PgColumn<import("../column.js").ColumnBaseConfig<import("../column-builder.js").ColumnDataType, string>, {}, {}>[];
     indexes: Index[];
     foreignKeys: ForeignKey[];
     checks: Check[];
@@ -18,26 +18,26 @@ export declare function getTableConfig<TTable extends PgTable>(table: TTable): {
     schema: string | undefined;
 };
 export declare function getViewConfig<TName extends string = string, TExisting extends boolean = boolean>(view: PgView<TName, TExisting>): {
-    with?: import("./view").ViewWithConfig | undefined;
+    with?: import("./view.js").ViewWithConfig | undefined;
     name: TName;
     originalName: TName;
     schema: string | undefined;
-    selectedFields: import("..").SelectedFields<import("..").AnyColumn, Table<import("../table").TableConfig<import("..").Column<any, object, object>>>>;
+    selectedFields: import("../operations.js").SelectedFields<import("../column.js").AnyColumn, Table<import("../table.js").TableConfig<import("../column.js").Column<any, object, object>>>>;
     isExisting: TExisting;
-    query: TExisting extends true ? undefined : import("..").SQL<unknown>;
+    query: TExisting extends true ? undefined : import("../index.js").SQL<unknown>;
     isAlias: boolean;
 };
 export declare function getMaterializedViewConfig<TName extends string = string, TExisting extends boolean = boolean>(view: PgMaterializedView<TName, TExisting>): {
-    with?: import("./view").PgMaterializedViewWithConfig | undefined;
+    with?: import("./view.js").PgMaterializedViewWithConfig | undefined;
     using?: string | undefined;
     tablespace?: string | undefined;
     withNoData?: boolean | undefined;
     name: TName;
     originalName: TName;
     schema: string | undefined;
-    selectedFields: import("..").SelectedFields<import("..").AnyColumn, Table<import("../table").TableConfig<import("..").Column<any, object, object>>>>;
+    selectedFields: import("../operations.js").SelectedFields<import("../column.js").AnyColumn, Table<import("../table.js").TableConfig<import("../column.js").Column<any, object, object>>>>;
     isExisting: TExisting;
-    query: TExisting extends true ? undefined : import("..").SQL<unknown>;
+    query: TExisting extends true ? undefined : import("../index.js").SQL<unknown>;
     isAlias: boolean;
 };
 export declare function parsePgNestedArray(arrayString: string, startFrom?: number): [any[], number];

package/pg-core/view.d.cts

@@ -0,0 +1,143 @@
+import type { BuildColumns } from '../column-builder.js';
+import { entityKind } from '../entity.js';
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { SQL } from '../sql/index.js';
+import { type ColumnsSelection, View } from '../view.js';
+import type { PgColumnBuilderBase } from './columns/common.js';
+import { QueryBuilder } from './query-builders/index.js';
+import type { SelectedFields } from './query-builders/select.types.js';
+export interface ViewWithConfig {
+    checkOption: 'local' | 'cascaded';
+    securityBarrier: boolean;
+    securityInvoker: boolean;
+}
+export declare class DefaultViewBuilderCore<TConfig extends {
+    name: string;
+    columns?: unknown;
+}> {
+    protected name: TConfig['name'];
+    protected schema: string | undefined;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly name: TConfig['name'];
+        readonly columns: TConfig['columns'];
+    };
+    constructor(name: TConfig['name'], schema: string | undefined);
+    protected config: {
+        with?: ViewWithConfig;
+    };
+    with(config: ViewWithConfig): this;
+}
+export declare class ViewBuilder<TName extends string = string> extends DefaultViewBuilderCore<{
+    name: TName;
+}> {
+    static readonly [entityKind]: string;
+    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
+}
+export declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>> extends DefaultViewBuilderCore<{
+    name: TName;
+    columns: TColumns;
+}> {
+    static readonly [entityKind]: string;
+    private columns;
+    constructor(name: TName, columns: TColumns, schema: string | undefined);
+    existing(): PgViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+    as(query: SQL): PgViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
+}
+export interface PgMaterializedViewWithConfig {
+    [Key: string]: string | number | boolean | SQL;
+}
+export declare class MaterializedViewBuilderCore<TConfig extends {
+    name: string;
+    columns?: unknown;
+}> {
+    protected name: TConfig['name'];
+    protected schema: string | undefined;
+    static readonly [entityKind]: string;
+    _: {
+        readonly name: TConfig['name'];
+        readonly columns: TConfig['columns'];
+    };
+    constructor(name: TConfig['name'], schema: string | undefined);
+    protected config: {
+        with?: PgMaterializedViewWithConfig;
+        using?: string;
+        tablespace?: string;
+        withNoData?: boolean;
+    };
+    using(using: string): this;
+    with(config: PgMaterializedViewWithConfig): this;
+    tablespace(tablespace: string): this;
+    withNoData(): this;
+}
+export declare class MaterializedViewBuilder<TName extends string = string> extends MaterializedViewBuilderCore<{
+    name: TName;
+}> {
+    static readonly [entityKind]: string;
+    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgMaterializedViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
+}
+export declare class ManualMaterializedViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>> extends MaterializedViewBuilderCore<{
+    name: TName;
+    columns: TColumns;
+}> {
+    static readonly [entityKind]: string;
+    private columns;
+    constructor(name: TName, columns: TColumns, schema: string | undefined);
+    existing(): PgMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+    as(query: SQL): PgMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
+}
+export declare abstract class PgViewBase<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends View<TName, TExisting, TSelectedFields> {
+    static readonly [entityKind]: string;
+    readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
+        readonly viewBrand: 'PgViewBase';
+    };
+}
+export declare const PgViewConfig: unique symbol;
+export declare class PgView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
+    static readonly [entityKind]: string;
+    [PgViewConfig]: {
+        with?: ViewWithConfig;
+    } | undefined;
+    constructor({ pgConfig, config }: {
+        pgConfig: {
+            with?: ViewWithConfig;
+        } | undefined;
+        config: {
+            name: TName;
+            schema: string | undefined;
+            selectedFields: SelectedFields;
+            query: SQL | undefined;
+        };
+    });
+}
+export type PgViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgView<TName, TExisting, TSelectedFields> & TSelectedFields;
+export declare const PgMaterializedViewConfig: unique symbol;
+export declare class PgMaterializedView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
+    static readonly [entityKind]: string;
+    readonly [PgMaterializedViewConfig]: {
+        readonly with?: PgMaterializedViewWithConfig;
+        readonly using?: string;
+        readonly tablespace?: string;
+        readonly withNoData?: boolean;
+    } | undefined;
+    constructor({ pgConfig, config }: {
+        pgConfig: {
+            with: PgMaterializedViewWithConfig | undefined;
+            using: string | undefined;
+            tablespace: string | undefined;
+            withNoData: boolean | undefined;
+        } | undefined;
+        config: {
+            name: TName;
+            schema: string | undefined;
+            selectedFields: SelectedFields;
+            query: SQL | undefined;
+        };
+    });
+}
+export type PgMaterializedViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgMaterializedView<TName, TExisting, TSelectedFields> & TSelectedFields;
+export declare function pgView<TName extends string>(name: TName): ViewBuilder<TName>;
+export declare function pgView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
+export declare function pgMaterializedView<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
+export declare function pgMaterializedView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(name: TName, columns: TColumns): ManualMaterializedViewBuilder<TName, TColumns>;

package/pg-core/view.d.mts

@@ -0,0 +1,143 @@
+import type { BuildColumns } from '../column-builder.js';
+import { entityKind } from '../entity.js';
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { SQL } from '../sql/index.js';
+import { type ColumnsSelection, View } from '../view.js';
+import type { PgColumnBuilderBase } from './columns/common.js';
+import { QueryBuilder } from './query-builders/index.js';
+import type { SelectedFields } from './query-builders/select.types.js';
+export interface ViewWithConfig {
+    checkOption: 'local' | 'cascaded';
+    securityBarrier: boolean;
+    securityInvoker: boolean;
+}
+export declare class DefaultViewBuilderCore<TConfig extends {
+    name: string;
+    columns?: unknown;
+}> {
+    protected name: TConfig['name'];
+    protected schema: string | undefined;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly name: TConfig['name'];
+        readonly columns: TConfig['columns'];
+    };
+    constructor(name: TConfig['name'], schema: string | undefined);
+    protected config: {
+        with?: ViewWithConfig;
+    };
+    with(config: ViewWithConfig): this;
+}
+export declare class ViewBuilder<TName extends string = string> extends DefaultViewBuilderCore<{
+    name: TName;
+}> {
+    static readonly [entityKind]: string;
+    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
+}
+export declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>> extends DefaultViewBuilderCore<{
+    name: TName;
+    columns: TColumns;
+}> {
+    static readonly [entityKind]: string;
+    private columns;
+    constructor(name: TName, columns: TColumns, schema: string | undefined);
+    existing(): PgViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+    as(query: SQL): PgViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
+}
+export interface PgMaterializedViewWithConfig {
+    [Key: string]: string | number | boolean | SQL;
+}
+export declare class MaterializedViewBuilderCore<TConfig extends {
+    name: string;
+    columns?: unknown;
+}> {
+    protected name: TConfig['name'];
+    protected schema: string | undefined;
+    static readonly [entityKind]: string;
+    _: {
+        readonly name: TConfig['name'];
+        readonly columns: TConfig['columns'];
+    };
+    constructor(name: TConfig['name'], schema: string | undefined);
+    protected config: {
+        with?: PgMaterializedViewWithConfig;
+        using?: string;
+        tablespace?: string;
+        withNoData?: boolean;
+    };
+    using(using: string): this;
+    with(config: PgMaterializedViewWithConfig): this;
+    tablespace(tablespace: string): this;
+    withNoData(): this;
+}
+export declare class MaterializedViewBuilder<TName extends string = string> extends MaterializedViewBuilderCore<{
+    name: TName;
+}> {
+    static readonly [entityKind]: string;
+    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgMaterializedViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
+}
+export declare class ManualMaterializedViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>> extends MaterializedViewBuilderCore<{
+    name: TName;
+    columns: TColumns;
+}> {
+    static readonly [entityKind]: string;
+    private columns;
+    constructor(name: TName, columns: TColumns, schema: string | undefined);
+    existing(): PgMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+    as(query: SQL): PgMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
+}
+export declare abstract class PgViewBase<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends View<TName, TExisting, TSelectedFields> {
+    static readonly [entityKind]: string;
+    readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
+        readonly viewBrand: 'PgViewBase';
+    };
+}
+export declare const PgViewConfig: unique symbol;
+export declare class PgView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
+    static readonly [entityKind]: string;
+    [PgViewConfig]: {
+        with?: ViewWithConfig;
+    } | undefined;
+    constructor({ pgConfig, config }: {
+        pgConfig: {
+            with?: ViewWithConfig;
+        } | undefined;
+        config: {
+            name: TName;
+            schema: string | undefined;
+            selectedFields: SelectedFields;
+            query: SQL | undefined;
+        };
+    });
+}
+export type PgViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgView<TName, TExisting, TSelectedFields> & TSelectedFields;
+export declare const PgMaterializedViewConfig: unique symbol;
+export declare class PgMaterializedView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
+    static readonly [entityKind]: string;
+    readonly [PgMaterializedViewConfig]: {
+        readonly with?: PgMaterializedViewWithConfig;
+        readonly using?: string;
+        readonly tablespace?: string;
+        readonly withNoData?: boolean;
+    } | undefined;
+    constructor({ pgConfig, config }: {
+        pgConfig: {
+            with: PgMaterializedViewWithConfig | undefined;
+            using: string | undefined;
+            tablespace: string | undefined;
+            withNoData: boolean | undefined;
+        } | undefined;
+        config: {
+            name: TName;
+            schema: string | undefined;
+            selectedFields: SelectedFields;
+            query: SQL | undefined;
+        };
+    });
+}
+export type PgMaterializedViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgMaterializedView<TName, TExisting, TSelectedFields> & TSelectedFields;
+export declare function pgView<TName extends string>(name: TName): ViewBuilder<TName>;
+export declare function pgView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
+export declare function pgMaterializedView<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
+export declare function pgMaterializedView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(name: TName, columns: TColumns): ManualMaterializedViewBuilder<TName, TColumns>;

package/pg-core/view.d.ts

@@ -1,12 +1,12 @@
-import type { BuildColumns } from '../column-builder';
-import { entityKind } from '../entity';
-import type { TypedQueryBuilder } from '../query-builders/query-builder';
-import type { AddAliasToSelection } from '../query-builders/select.types';
-import type { SQL } from '../sql';
-import { type ColumnsSelection, View } from '../view';
-import type { PgColumnBuilder } from './columns/common';
-import { QueryBuilder } from './query-builders';
-import type { SelectedFields } from './query-builders/select.types';
+import type { BuildColumns } from '../column-builder.js';
+import { entityKind } from '../entity.js';
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { SQL } from '../sql/index.js';
+import { type ColumnsSelection, View } from '../view.js';
+import type { PgColumnBuilderBase } from './columns/common.js';
+import { QueryBuilder } from './query-builders/index.js';
+import type { SelectedFields } from './query-builders/select.types.js';
 export interface ViewWithConfig {
     checkOption: 'local' | 'cascaded';
     securityBarrier: boolean;
@@ -35,7 +35,7 @@ export declare class ViewBuilder<TName extends string = string> extends DefaultV
     static readonly [entityKind]: string;
     as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
 }
-export declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilder> = Record<string, PgColumnBuilder>> extends DefaultViewBuilderCore<{
+export declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>> extends DefaultViewBuilderCore<{
     name: TName;
     columns: TColumns;
 }> {
@@ -77,7 +77,7 @@ export declare class MaterializedViewBuilder<TName extends string = string> exte
     static readonly [entityKind]: string;
     as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgMaterializedViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
 }
-export declare class ManualMaterializedViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilder> = Record<string, PgColumnBuilder>> extends MaterializedViewBuilderCore<{
+export declare class ManualMaterializedViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>> extends MaterializedViewBuilderCore<{
     name: TName;
     columns: TColumns;
 }> {
@@ -138,6 +138,6 @@ export declare class PgMaterializedView<TName extends string = string, TExisting
 }
 export type PgMaterializedViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgMaterializedView<TName, TExisting, TSelectedFields> & TSelectedFields;
 export declare function pgView<TName extends string>(name: TName): ViewBuilder<TName>;
-export declare function pgView<TName extends string, TColumns extends Record<string, PgColumnBuilder>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
+export declare function pgView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
 export declare function pgMaterializedView<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
-export declare function pgMaterializedView<TName extends string, TColumns extends Record<string, PgColumnBuilder>>(name: TName, columns: TColumns): ManualMaterializedViewBuilder<TName, TColumns>;
+export declare function pgMaterializedView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(name: TName, columns: TColumns): ManualMaterializedViewBuilder<TName, TColumns>;

package/planetscale-serverless/driver.d.cts

@@ -0,0 +1,10 @@
+import type { Connection } from '@planetscale/database';
+import type { Logger } from '../logger.js';
+import { MySqlDatabase } from '../mysql-core/db.js';
+import { type DrizzleConfig } from '../utils.js';
+import type { PlanetScalePreparedQueryHKT, PlanetscaleQueryResultHKT } from './session.js';
+export interface PlanetscaleSDriverOptions {
+    logger?: Logger;
+}
+export type PlanetScaleDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = MySqlDatabase<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, TSchema>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: Connection, config?: DrizzleConfig<TSchema>): PlanetScaleDatabase<TSchema>;

package/planetscale-serverless/driver.d.mts

@@ -0,0 +1,10 @@
+import type { Connection } from '@planetscale/database';
+import type { Logger } from '../logger.js';
+import { MySqlDatabase } from '../mysql-core/db.js';
+import { type DrizzleConfig } from '../utils.js';
+import type { PlanetScalePreparedQueryHKT, PlanetscaleQueryResultHKT } from './session.js';
+export interface PlanetscaleSDriverOptions {
+    logger?: Logger;
+}
+export type PlanetScaleDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = MySqlDatabase<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, TSchema>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: Connection, config?: DrizzleConfig<TSchema>): PlanetScaleDatabase<TSchema>;

package/planetscale-serverless/driver.d.ts

@@ -1,8 +1,8 @@
 import type { Connection } from '@planetscale/database';
-import type { Logger } from '../logger';
-import { MySqlDatabase } from '../mysql-core/db';
-import { type DrizzleConfig } from '../utils';
-import type { PlanetScalePreparedQueryHKT, PlanetscaleQueryResultHKT } from './session';
+import type { Logger } from '../logger.js';
+import { MySqlDatabase } from '../mysql-core/db.js';
+import { type DrizzleConfig } from '../utils.js';
+import type { PlanetScalePreparedQueryHKT, PlanetscaleQueryResultHKT } from './session.js';
 export interface PlanetscaleSDriverOptions {
     logger?: Logger;
 }

package/planetscale-serverless/index.cjs

@@ -1,11 +1,11 @@
 'use strict';
 
-var index = require('../index.cjs');
-var session = require('../session-690cd067.cjs');
-var alias = require('../alias-58b7b8c9.cjs');
+var index = require('../index-b1dbb7ec.cjs');
+var view = require('../view-e96fe3b6.cjs');
+require('@opentelemetry/api');
 
 var _a, _b, _c;
-class PlanetScalePreparedQuery extends session.PreparedQuery {
+class PlanetScalePreparedQuery extends view.PreparedQuery {
     constructor(client, queryString, params, logger, fields, customResultMapper) {
         super();
         this.client = client;
@@ -18,7 +18,7 @@ class PlanetScalePreparedQuery extends session.PreparedQuery {
         this.query = { as: 'array' };
     }
     async execute(placeholderValues = {}) {
-        const params = alias.fillPlaceholders(this.params, placeholderValues);
+        const params = index.fillPlaceholders(this.params, placeholderValues);
         this.logger.logQuery(this.queryString, params);
         const { fields, client, queryString, rawQuery, query, joinsNotNullableMap, customResultMapper } = this;
         if (!fields && !customResultMapper) {
@@ -28,15 +28,15 @@ class PlanetScalePreparedQuery extends session.PreparedQuery {
         if (customResultMapper) {
             return customResultMapper(rows);
         }
-        return rows.map((row) => alias.mapResultRow(fields, row, joinsNotNullableMap));
+        return rows.map((row) => index.mapResultRow(fields, row, joinsNotNullableMap));
     }
     iterator(_placeholderValues) {
         throw new Error('Streaming is not supported by the PlanetScale Serverless driver');
     }
 }
-_a = alias.entityKind;
+_a = index.entityKind;
 PlanetScalePreparedQuery[_a] = 'PlanetScalePreparedQuery';
-class PlanetscaleSession extends session.MySqlSession {
+class PlanetscaleSession extends view.MySqlSession {
     constructor(baseClient, dialect, tx, schema, options = {}) {
         super(dialect);
         this.baseClient = baseClient;
@@ -68,32 +68,32 @@ class PlanetscaleSession extends session.MySqlSession {
         });
     }
 }
-_b = alias.entityKind;
+_b = index.entityKind;
 PlanetscaleSession[_b] = 'PlanetscaleSession';
-class PlanetScaleTransaction extends session.MySqlTransaction {
+class PlanetScaleTransaction extends view.MySqlTransaction {
     constructor(dialect, session, schema, nestedIndex = 0) {
         super(dialect, session, schema, nestedIndex, 'planetscale');
     }
     async transaction(transaction) {
         const savepointName = `sp${this.nestedIndex + 1}`;
         const tx = new PlanetScaleTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
-        await tx.execute(alias.sql.raw(`savepoint ${savepointName}`));
+        await tx.execute(index.sql.raw(`savepoint ${savepointName}`));
         try {
             const result = await transaction(tx);
-            await tx.execute(alias.sql.raw(`release savepoint ${savepointName}`));
+            await tx.execute(index.sql.raw(`release savepoint ${savepointName}`));
             return result;
         }
         catch (err) {
-            await tx.execute(alias.sql.raw(`rollback to savepoint ${savepointName}`));
+            await tx.execute(index.sql.raw(`rollback to savepoint ${savepointName}`));
             throw err;
         }
     }
 }
-_c = alias.entityKind;
+_c = index.entityKind;
 PlanetScaleTransaction[_c] = 'PlanetScaleTransaction';
 
 function drizzle(client, config = {}) {
-    const dialect = new session.MySqlDialect();
+    const dialect = new view.MySqlDialect();
     let logger;
     if (config.logger === true) {
         logger = new index.DefaultLogger();
@@ -103,15 +103,15 @@ function drizzle(client, config = {}) {
     }
     let schema;
     if (config.schema) {
-        const tablesConfig = alias.extractTablesRelationalConfig(config.schema, alias.createTableRelationsHelpers);
+        const tablesConfig = index.extractTablesRelationalConfig(config.schema, index.createTableRelationsHelpers);
         schema = {
             fullSchema: config.schema,
             schema: tablesConfig.tables,
             tableNamesMap: tablesConfig.tableNamesMap,
         };
     }
-    const session$1 = new PlanetscaleSession(client, dialect, undefined, schema, { logger });
-    return new session.MySqlDatabase(dialect, session$1, schema, 'planetscale');
+    const session = new PlanetscaleSession(client, dialect, undefined, schema, { logger });
+    return new view.MySqlDatabase(dialect, session, schema, 'planetscale');
 }
 
 exports.PlanetScalePreparedQuery = PlanetScalePreparedQuery;