@forinda/kickjs-db 8.12.4 → 8.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (68) hide show
  1. package/bin/kickjs-db.mjs +11 -27
  2. package/dist/{adapter-cVrkWrul.d.mts → adapter-HRQJb4xQ.d.mts} +2 -4
  3. package/dist/adapter-HRQJb4xQ.d.mts.map +1 -0
  4. package/dist/cli.d.mts +39 -9
  5. package/dist/cli.d.mts.map +1 -1
  6. package/dist/cli.mjs +4 -4
  7. package/dist/cli.mjs.map +1 -1
  8. package/dist/{create-NrvNUwZr.mjs → create-BGFj2wGn.mjs} +3 -3
  9. package/dist/create-BGFj2wGn.mjs.map +1 -0
  10. package/dist/{custom-type-CNmg8h4k.mjs → custom-type-CyQYFrA5.mjs} +2 -2
  11. package/dist/custom-type-CyQYFrA5.mjs.map +1 -0
  12. package/dist/devtools-events.d.mts +1 -3
  13. package/dist/devtools-events.d.mts.map +1 -1
  14. package/dist/devtools-events.mjs +1 -1
  15. package/dist/{index-Nf43jLx4.d.mts → index-AaU739CK.d.mts} +329 -135
  16. package/dist/index-AaU739CK.d.mts.map +1 -0
  17. package/dist/index.d.mts +5 -5
  18. package/dist/index.mjs +2 -2
  19. package/dist/mysql.d.mts +2 -8
  20. package/dist/mysql.d.mts.map +1 -1
  21. package/dist/mysql.mjs +2 -2
  22. package/dist/mysql.mjs.map +1 -1
  23. package/dist/{pg-lghOiA3k.mjs → pg-0Zp1q4gP.mjs} +3 -3
  24. package/dist/{pg-lghOiA3k.mjs.map → pg-0Zp1q4gP.mjs.map} +1 -1
  25. package/dist/pg.d.mts +4 -12
  26. package/dist/pg.d.mts.map +1 -1
  27. package/dist/pg.mjs +2 -2
  28. package/dist/pg.mjs.map +1 -1
  29. package/dist/pglite.d.mts +1 -3
  30. package/dist/pglite.d.mts.map +1 -1
  31. package/dist/pglite.mjs +1 -1
  32. package/dist/pglite.mjs.map +1 -1
  33. package/dist/{schema-types-CdU4u-Ow.d.mts → schema-types-CsgTPOPi.d.mts} +9 -5
  34. package/dist/schema-types-CsgTPOPi.d.mts.map +1 -0
  35. package/dist/{schema-jLdsVhUe.d.mts → schema-v6Jgocab.d.mts} +3 -5
  36. package/dist/schema-v6Jgocab.d.mts.map +1 -0
  37. package/dist/schema.d.mts +1 -1
  38. package/dist/schema.mjs +2 -2
  39. package/dist/schema.mjs.map +1 -1
  40. package/dist/{split-statements-cNBnqF81.mjs → split-statements-DHYNJs5X.mjs} +2 -2
  41. package/dist/{split-statements-cNBnqF81.mjs.map → split-statements-DHYNJs5X.mjs.map} +1 -1
  42. package/dist/sqlite.d.mts +1 -7
  43. package/dist/sqlite.d.mts.map +1 -1
  44. package/dist/sqlite.mjs +2 -2
  45. package/dist/sqlite.mjs.map +1 -1
  46. package/dist/{src-BkewQb59.mjs → src-CBTegE76.mjs} +4 -4
  47. package/dist/src-CBTegE76.mjs.map +1 -0
  48. package/dist/{table-BGk08X3C.d.mts → table-B8eYtdq_.d.mts} +7 -8
  49. package/dist/table-B8eYtdq_.d.mts.map +1 -0
  50. package/dist/testing.d.mts +2 -4
  51. package/dist/testing.d.mts.map +1 -1
  52. package/dist/testing.mjs +2 -2
  53. package/dist/testing.mjs.map +1 -1
  54. package/dist/{types-8xZUYm43.d.mts → types-Bmbj69hY.d.mts} +79 -17
  55. package/dist/types-Bmbj69hY.d.mts.map +1 -0
  56. package/dist/{types-DB_xyeQT.d.mts → types-D4x2u-EZ.d.mts} +22 -5
  57. package/dist/types-D4x2u-EZ.d.mts.map +1 -0
  58. package/package.json +11 -11
  59. package/dist/adapter-cVrkWrul.d.mts.map +0 -1
  60. package/dist/create-NrvNUwZr.mjs.map +0 -1
  61. package/dist/custom-type-CNmg8h4k.mjs.map +0 -1
  62. package/dist/index-Nf43jLx4.d.mts.map +0 -1
  63. package/dist/schema-jLdsVhUe.d.mts.map +0 -1
  64. package/dist/schema-types-CdU4u-Ow.d.mts.map +0 -1
  65. package/dist/src-BkewQb59.mjs.map +0 -1
  66. package/dist/table-BGk08X3C.d.mts.map +0 -1
  67. package/dist/types-8xZUYm43.d.mts.map +0 -1
  68. package/dist/types-DB_xyeQT.d.mts.map +0 -1
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index-AaU739CK.d.mts","names":["Dialect","Kysely","Dialect","Dialect","Dialect","Dialect","Dialect","Kysely","KyselyPlugin","Expression","SqlBool","RawBuilder","Expression"],"sources":["../src/migrate/adapter.ts","../src/migrate/drift.ts","../src/cli/config.ts","../src/snapshot/casing.ts","../src/snapshot/extract.ts","../src/snapshot/name.ts","../src/snapshot/render.ts","../src/diff/types.ts","../src/diff/engine.ts","../src/diff/invert.ts","../src/errors.ts","../src/diff/composite-detect.ts","../src/query/relations.ts","../src/client/wrap.ts","../src/db-errors.ts","../src/migrate/errors.ts","../src/migrate/enum-drop-gate.ts","../src/migrate/journal.ts","../src/migrate/schema.ts","../src/migrate/memory-adapter.ts","../src/migrate/introspect-types.ts","../src/migrate/introspect-pg.ts","../src/migrate/introspect-sqlite.ts","../src/migrate/introspect-mysql.ts","../src/migrate/code-migration.ts","../src/migrate/source.ts","../src/adapter.ts","../src/tokens.ts","../src/client/create.ts","../src/client/plugins.ts","../src/migrate/runner.ts","../src/migrate/tenants.ts","../src/migrate/review.ts","../src/migrate/push.ts","../src/emit/pg.ts","../src/emit/sqlite.ts","../src/emit/mysql.ts","../src/cli/generate.ts","../src/cli/check.ts","../src/cli/seed.ts","../src/seed/fake.ts","../src/dsl/columns/builders.ts","../src/dsl/view.ts","../src/dsl/self-ref.ts","../src/dsl/table-forms.ts","../src/dsl/alias.ts","../src/query/operators.ts","../src/dsl/relations.ts","../src/custom-type.ts","../src/query/schema-relations-types.ts","../src/query/errors.ts","../src/query/like.ts","../src/query/order.ts","../src/dialect-marker.ts"],"mappings":"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"}
package/dist/index.d.mts CHANGED
@@ -1,7 +1,7 @@
1
1
 
2
- import { C as RelationSnapshot, E as TableSnapshot, T as SchemaSnapshot, _ as Dialect, a as FkSpec, b as ForeignKeySnapshot, c as KICK_GENERATED, g as ColumnSnapshot, h as CheckSnapshot, i as ColumnState, l as KICK_NOT_NULL, m as TypedColumnRefs, n as ColumnBuilder, p as TypedColumnRef, r as ColumnRef, s as GeneratedBrand, u as NotNullBrand, v as EnumSnapshot, x as IndexSnapshot, y as FkAction } from "./types-DB_xyeQT.mjs";
3
- import { $ as inArray, $i as checkDrift, $n as CodeMigration, $r as detectCompositeReferences, $t as time, A as RelationalQueryUnknownRelationError, Ai as DropPolicy, An as TenantMigrationResult, Ar as MigrationError, At as buildView, B as RelationMorphTo, Bi as renderSchemaSource, Bn as migrateStatus, Br as DbDialect, Bt as date, C as RelationalQueryAliasCollisionError, Ci as CreateTable, Cn as PushOptions, Cr as readJournal, Ct as link, D as RelationalQueryMissingInverseError, Di as DropEnum, Dn as reviewMigration, Dr as parseEnumDropHeader, Dt as ViewDecl, E as RelationalQueryDepthError, Ei as DropColumn, En as ReviewResult, Er as enforceEnumDropGate, Et as MaterializedViewOptions, F as MorphSpec, Fi as RenameColumn, Fn as RunnerOptions, Fr as UnreviewedMigrationError, Ft as bigSerial, G as Operand, Gi as toKeyName, Gn as DB_PRIMARY, Gr as UniqueViolationError, Gt as json, H as RelationsDecl, Hi as extractSnapshot, Hn as safeNullComparison, Hr as ForeignKeyViolationError, Ht as doublePrecision, I as MorphToSpec, Ii as RenameTable, In as StatusEntry, Ir as CheckViolationError, It as bigint, J as eq, Jn as MigrationsOnBoot, Jr as ResolvedRelation, Jt as real, K as and, Ki as DbConfig, Kn as DB_REPLICA, Kr as translateDbError, Kt as jsonb, L as Relation, Li as SetColumnComment, Ln as migrateDown, Lr as ConnectionError, Lt as boolean, M as CustomColumnBuilder, Mi as DropView, Mn as AppliedSummary, Mr as MigrationHashError, Mt as view, N as CustomTypeOptions, Ni as PrimaryKeyShape, Nn as ReversedSummary, Nr as MigrationLockError, Nt as TimestampBuilder, O as RelationalQueryNotSupportedError, Oi as DropForeignKey, On as MigrateTenantsOptions, Or as MigrationDriftError, Ot as ViewMarks, P as customType, Pi as RemoveEnumValue, Pn as RollbackSummary, Pr as SchemaDiffSummary, Pt as UuidBuilder, Q as ilike, Qi as DriftLogger, Qn as migrationFiles, Qr as CompositeRef, Qt as text, R as RelationMany, Ri as SetRowLevelSecurity, Rn as migrateLatest, Rr as DatabaseError, Rt as bytea, S as likePattern, Si as CreateSchema, Sn as emitPg, Sr as computeMigrationHash, St as fk, T as RelationalQueryCancelledError, Ti as DropCheck, Tn as pushSchema, Tr as EnumDropHeader, Tt as selfRef, U as ThroughSpec, Ui as Casing, Un as createDbClient, Ur as NotNullViolationError, Ut as integer, V as RelationOne, Vi as fitIdentifier, Vn as migrateUp, Vr as DeadlockError, Vt as decimal, W as relations, Wi as toDbName, Wn as DB_CLIENT, Wr as SerializationFailureError, Wt as interval, X as gt, Xi as DriftBehavior, Xn as MigrationFiles, Xr as CompositeEnumReferenceError, Xt as smallSerial, Y as exists, Yi as resolveDbConfig, Yn as kickDbAdapter, Yr as ResolvedRelations, Yt as serial, Z as gte, Zi as DriftIgnore, Zn as MigrationsLocation, Zr as CompositeQueryRunner, Zt as smallint, _ as readDialectMark, _i as Change, _n as GenerateResult, _r as pushTableName, _t as StringRule, a as KyselyPlugin, ai as RenameCandidates, an as FakeContext, ar as SqliteIntrospectDb, at as ne, b as LikeMatchMode, bi as CreatePolicy, bn as SqliteRebuildRequiredError, br as JournalEntry, bt as TableDefinition, c as Selectable, ci as findRenameCandidates, cn as SeedFakeOptions, cr as introspectPg, ct as notInArray, d as Updateable, di as AddEnumValue, dn as SeedResult, dr as MemoryMigrationAdapter, dt as AliasedTable, ea as MigrationAdapter, ei as KickDbError, en as timestamp, er as MigrationDb, et as isNotNull, f as sql, fi as AddForeignKey, fn as listSeeds, fr as KICK_LOCK_TABLE, ft as alias, g as markDialect, gi as AlterRole, gn as GenerateOptions, gr as migrationsTableDdl, gt as RuleFor, h as isDialectTag, hi as AlterPrimaryKey, hn as checkMigrations, hr as lockTableName, ht as Rule, i as Kysely, ii as DiffOptions, in as version, ir as IntrospectSqliteOptions, it as lte, j as SchemaToRelationsRegister, ji as DropTable, jn as migrateTenants, jr as MigrationFailedError, jt as isView, k as RelationalQueryThroughError, ki as DropIndex, kn as MigrateTenantsResult, kr as MigrationEnumDropError, kt as ViewOptions, l as Sql, li as AddCheck, ln as fakeRows, lr as IntrospectPgOptions, lt as notLike, m as KICK_DIALECT, mi as AlterColumn, mn as CheckResult, mr as lockTableDdl, mt as NumberRule, n as ExpressionBuilder, na as MigrationRow, ni as hasAmbiguousReverse, nn as uuid, nr as MysqlIntrospectDb, nt as like, o as RawBuilder, oi as RenameHints, on as FakeOverride, or as introspectSqlite, ot as not, p as DialectTag, pi as AddIndex, pn as runSeeds, pr as KICK_MIGRATIONS_TABLE, pt as ClassRefs, q as between, qn as KickDbAdapterConfig, qr as TransactionFinishedError, qt as numeric, r as Insertable, ri as invertChanges, rn as varchar, rr as introspectMysql, rt as lt, s as ReadonlyKysely, si as diff, sn as FakeRowsOptions, sr as introspectSqliteAsync, st as notExists, t as Expression, ta as MigrationBookkeeping, ti as RemovedValueAsDefaultError, tn as timestamptz, tr as IntrospectMysqlOptions, tt as isNull, u as SqlBool, ui as AddColumn, un as seedFake, ur as PgQueryRunner, ut as or, v as asc, vi as ChangeSet, vn as generate, vr as quoteTable, vt as TableBase, w as RelationalQueryAmbiguousRelationNameError, wi as CreateView, wn as PushResult, wr as verifyMigrationHash, wt as tableFromClass, x as escapeLike, xi as CreateRole, xn as emitSqlite, xr as appendJournalEntry, xt as defineTable, y as desc, yi as CreateEnum, yn as emitMysql, yr as Journal, yt as TableClass, z as RelationMorphOne, zi as SetTableComment, zn as migrateRollback, zr as DatabaseErrorInfo, zt as char } from "./index-Nf43jLx4.mjs";
4
- import { A as TenancyStrategy, C as WithClause, D as BypassOptions, E as BypassInfo, F as ExtensionDefinition, I as ModelExtensions, L as FindOrCreateOptions, M as defineTenancy, N as tenantKey, O as Tenancy, P as ExtendedClient, R as UpsertOptions, S as TableRelations, T as RegisteredDB, _ as KickDbRelationsRegister, a as ManualTransaction, b as RelationMapEntry, c as ReadRoute, d as TransactionEvent, f as TransactionOptions, g as FindManyRow, h as FindManyOptions, i as KickDbClientEvents, j as TenantRequiredError, k as TenancyOptions, l as ReadRouter, m as TransactionRollbackEvent, n as CreateDbClientOptions, o as QueryErrorEvent, p as TransactionRetryEvent, r as KickDbClient, s as QueryEvent, t as BeforeQueryEvent, v as QueryNamespace, w as KickDbRegister, x as TableQueryNamespace, y as RegisteredRelations, z as InsertManyOptions } from "./types-8xZUYm43.mjs";
5
- import { a as qualifiedTableName, c as CheckDecl, d as PrimaryKeyDecl, f as TableConstraint, g as unique, h as primaryKey, i as buildTable, l as IndexDecl, m as index, n as TableDecl, o as table, p as check, r as TableOptions, s as unwrapTable, t as QualifiedName, u as IndexKey } from "./table-BGk08X3C.mjs";
6
- import { t as SchemaToTypes } from "./schema-types-CdU4u-Ow.mjs";
2
+ import { C as RelationSnapshot, E as TableSnapshot, T as SchemaSnapshot, _ as Dialect, a as FkSpec, b as ForeignKeySnapshot, c as KICK_GENERATED, g as ColumnSnapshot, h as CheckSnapshot, i as ColumnState, l as KICK_NOT_NULL, m as TypedColumnRefs, n as ColumnBuilder, p as TypedColumnRef, r as ColumnRef, s as GeneratedBrand, u as NotNullBrand, v as EnumSnapshot, x as IndexSnapshot, y as FkAction } from "./types-D4x2u-EZ.mjs";
3
+ import { $ as inArray, $i as checkDrift, $n as CodeMigration, $r as detectCompositeReferences, $t as time, A as RelationalQueryUnknownRelationError, Ai as DropPolicy, An as TenantMigrationResult, Ar as MigrationError, At as buildView, B as RelationMorphTo, Bi as renderSchemaSource, Bn as migrateStatus, Br as DbDialect, Bt as date, C as RelationalQueryAliasCollisionError, Ci as CreateTable, Cn as PushOptions, Cr as readJournal, Ct as link, D as RelationalQueryMissingInverseError, Di as DropEnum, Dn as reviewMigration, Dr as parseEnumDropHeader, Dt as ViewDecl, E as RelationalQueryDepthError, Ei as DropColumn, En as ReviewResult, Er as enforceEnumDropGate, Et as MaterializedViewOptions, F as MorphSpec, Fi as RenameColumn, Fn as RunnerOptions, Fr as UnreviewedMigrationError, Ft as bigSerial, G as Operand, Gi as toKeyName, Gn as DB_PRIMARY, Gr as UniqueViolationError, Gt as json, H as RelationsDecl, Hi as extractSnapshot, Hn as safeNullComparison, Hr as ForeignKeyViolationError, Ht as doublePrecision, I as MorphToSpec, Ii as RenameTable, In as StatusEntry, Ir as CheckViolationError, It as bigint, J as eq, Jn as MigrationsOnBoot, Jr as ResolvedRelation, Jt as real, K as and, Ki as DbConfig, Kn as DB_REPLICA, Kr as translateDbError, Kt as jsonb, L as Relation, Li as SetColumnComment, Ln as migrateDown, Lr as ConnectionError, Lt as boolean, M as CustomColumnBuilder, Mi as DropView, Mn as AppliedSummary, Mr as MigrationHashError, Mt as view, N as CustomTypeOptions, Ni as PrimaryKeyShape, Nn as ReversedSummary, Nr as MigrationLockError, Nt as TimestampBuilder, O as RelationalQueryNotSupportedError, Oi as DropForeignKey, On as MigrateTenantsOptions, Or as MigrationDriftError, Ot as ViewMarks, P as customType, Pi as RemoveEnumValue, Pn as RollbackSummary, Pr as SchemaDiffSummary, Pt as UuidBuilder, Q as ilike, Qi as DriftLogger, Qn as migrationFiles, Qr as CompositeRef, Qt as text, R as RelationMany, Ri as SetRowLevelSecurity, Rn as migrateLatest, Rr as DatabaseError, Rt as bytea, S as likePattern, Si as CreateSchema, Sn as emitPg, Sr as computeMigrationHash, St as fk, T as RelationalQueryCancelledError, Ti as DropCheck, Tn as pushSchema, Tr as EnumDropHeader, Tt as selfRef, U as ThroughSpec, Ui as Casing, Un as createDbClient, Ur as NotNullViolationError, Ut as integer, V as RelationOne, Vi as fitIdentifier, Vn as migrateUp, Vr as DeadlockError, Vt as decimal, W as relations, Wi as toDbName, Wn as DB_CLIENT, Wr as SerializationFailureError, Wt as interval, X as gt, Xi as DriftBehavior, Xn as MigrationFiles, Xr as CompositeEnumReferenceError, Xt as smallSerial, Y as exists, Yi as resolveDbConfig, Yn as kickDbAdapter, Yr as ResolvedRelations, Yt as serial, Z as gte, Zi as DriftIgnore, Zn as MigrationsLocation, Zr as CompositeQueryRunner, Zt as smallint, _ as readDialectMark, _i as Change, _n as GenerateResult, _r as pushTableName, _t as StringRule, a as KyselyPlugin, ai as RenameCandidates, an as FakeContext, ar as SqliteIntrospectDb, at as ne, b as LikeMatchMode, bi as CreatePolicy, bn as SqliteRebuildRequiredError, br as JournalEntry, bt as TableDefinition, c as Selectable, ci as findRenameCandidates, cn as SeedFakeOptions, cr as introspectPg, ct as notInArray, d as Updateable, di as AddEnumValue, dn as SeedResult, dr as MemoryMigrationAdapter, dt as AliasedTable, ea as MigrationAdapter, ei as KickDbError, en as timestamp, er as MigrationDb, et as isNotNull, f as sql, fi as AddForeignKey, fn as listSeeds, fr as KICK_LOCK_TABLE, ft as alias, g as markDialect, gi as AlterRole, gn as GenerateOptions, gr as migrationsTableDdl, gt as RuleFor, h as isDialectTag, hi as AlterPrimaryKey, hn as checkMigrations, hr as lockTableName, ht as Rule, i as Kysely, ii as DiffOptions, in as version, ir as IntrospectSqliteOptions, it as lte, j as SchemaToRelationsRegister, ji as DropTable, jn as migrateTenants, jr as MigrationFailedError, jt as isView, k as RelationalQueryThroughError, ki as DropIndex, kn as MigrateTenantsResult, kr as MigrationEnumDropError, kt as ViewOptions, l as Sql, li as AddCheck, ln as fakeRows, lr as IntrospectPgOptions, lt as notLike, m as KICK_DIALECT, mi as AlterColumn, mn as CheckResult, mr as lockTableDdl, mt as NumberRule, n as ExpressionBuilder, na as MigrationRow, ni as hasAmbiguousReverse, nn as uuid, nr as MysqlIntrospectDb, nt as like, o as RawBuilder, oi as RenameHints, on as FakeOverride, or as introspectSqlite, ot as not, p as DialectTag, pi as AddIndex, pn as runSeeds, pr as KICK_MIGRATIONS_TABLE, pt as ClassRefs, q as between, qn as KickDbAdapterConfig, qr as TransactionFinishedError, qt as numeric, r as Insertable, ri as invertChanges, rn as varchar, rr as introspectMysql, rt as lt, s as ReadonlyKysely, si as diff, sn as FakeRowsOptions, sr as introspectSqliteAsync, st as notExists, t as Expression, ta as MigrationBookkeeping, ti as RemovedValueAsDefaultError, tn as timestamptz, tr as IntrospectMysqlOptions, tt as isNull, u as SqlBool, ui as AddColumn, un as seedFake, ur as PgQueryRunner, ut as or, v as asc, vi as ChangeSet, vn as generate, vr as quoteTable, vt as TableBase, w as RelationalQueryAmbiguousRelationNameError, wi as CreateView, wn as PushResult, wr as verifyMigrationHash, wt as tableFromClass, x as escapeLike, xi as CreateRole, xn as emitSqlite, xr as appendJournalEntry, xt as defineTable, y as desc, yi as CreateEnum, yn as emitMysql, yr as Journal, yt as TableClass, z as RelationMorphOne, zi as SetTableComment, zn as migrateRollback, zr as DatabaseErrorInfo, zt as char } from "./index-AaU739CK.mjs";
4
+ import { A as TenancyStrategy, C as WithClause, D as BypassOptions, E as BypassInfo, F as ExtensionDefinition, I as ModelExtensions, L as FindOrCreateOptions, M as defineTenancy, N as tenantKey, O as Tenancy, P as ExtendedClient, R as UpsertOptions, S as TableRelations, T as RegisteredDB, _ as KickDbRelationsRegister, a as ManualTransaction, b as RelationMapEntry, c as ReadRoute, d as TransactionEvent, f as TransactionOptions, g as FindManyRow, h as FindManyOptions, i as KickDbClientEvents, j as TenantRequiredError, k as TenancyOptions, l as ReadRouter, m as TransactionRollbackEvent, n as CreateDbClientOptions, o as QueryErrorEvent, p as TransactionRetryEvent, r as KickDbClient, s as QueryEvent, t as BeforeQueryEvent, v as QueryNamespace, w as KickDbRegister, x as TableQueryNamespace, y as RegisteredRelations, z as InsertManyOptions } from "./types-Bmbj69hY.mjs";
5
+ import { a as qualifiedTableName, c as CheckDecl, d as PrimaryKeyDecl, f as TableConstraint, g as unique, h as primaryKey, i as buildTable, l as IndexDecl, m as index, n as TableDecl, o as table, p as check, r as TableOptions, s as unwrapTable, t as QualifiedName, u as IndexKey } from "./table-B8eYtdq_.mjs";
6
+ import { t as SchemaToTypes } from "./schema-types-CsgTPOPi.mjs";
7
7
  export { type AddCheck, type AddColumn, type AddEnumValue, type AddForeignKey, type AddIndex, type AliasedTable, type AlterColumn, type AlterPrimaryKey, type AlterRole, type AppliedSummary, type BeforeQueryEvent, BypassInfo, BypassOptions, type Casing, type Change, type ChangeSet, CheckDecl, type CheckResult, type CheckSnapshot, CheckViolationError, type ClassRefs, type CodeMigration, ColumnBuilder, type ColumnRef, type ColumnSnapshot, type ColumnState, CompositeEnumReferenceError, type CompositeQueryRunner, type CompositeRef, ConnectionError, type CreateDbClientOptions, type CreateEnum, type CreatePolicy, type CreateRole, type CreateSchema, type CreateTable, type CreateView, CustomColumnBuilder, type CustomTypeOptions, DB_CLIENT, DB_PRIMARY, DB_REPLICA, DatabaseError, type DatabaseErrorInfo, type DbConfig, type DbDialect, DeadlockError, type Dialect, type DialectTag, type DiffOptions, type DriftBehavior, type DriftIgnore, type DriftLogger, type DropCheck, type DropColumn, type DropEnum, type DropForeignKey, type DropIndex, type DropPolicy, type DropTable, type DropView, type EnumDropHeader, type EnumSnapshot, type Expression, type ExpressionBuilder, type ExtendedClient, type ExtensionDefinition, type FakeContext, type FakeOverride, type FakeRowsOptions, type FindManyOptions, type FindManyRow, type FindOrCreateOptions, type FkAction, type FkSpec, type ForeignKeySnapshot, ForeignKeyViolationError, type GenerateOptions, type GenerateResult, type GeneratedBrand, IndexDecl, IndexKey, type IndexSnapshot, type InsertManyOptions, type Insertable, type IntrospectMysqlOptions, type IntrospectPgOptions, type IntrospectSqliteOptions, type Journal, type JournalEntry, KICK_DIALECT, KICK_GENERATED, KICK_LOCK_TABLE, KICK_MIGRATIONS_TABLE, KICK_NOT_NULL, type KickDbAdapterConfig, type KickDbClient, type KickDbClientEvents, KickDbError, type KickDbRegister, type KickDbRelationsRegister, Kysely, type KyselyPlugin, type LikeMatchMode, type ManualTransaction, MaterializedViewOptions, MemoryMigrationAdapter, type MigrateTenantsOptions, type MigrateTenantsResult, type MigrationAdapter, type MigrationBookkeeping, type MigrationDb, MigrationDriftError, MigrationEnumDropError, MigrationError, MigrationFailedError, type MigrationFiles, MigrationHashError, MigrationLockError, type MigrationRow, type MigrationsLocation, type MigrationsOnBoot, type ModelExtensions, MorphSpec, MorphToSpec, type MysqlIntrospectDb, type NotNullBrand, NotNullViolationError, type NumberRule, Operand, type PgQueryRunner, PrimaryKeyDecl, type PrimaryKeyShape, type PushOptions, type PushResult, QualifiedName, type QueryErrorEvent, type QueryEvent, type QueryNamespace, type RawBuilder, type ReadRoute, type ReadRouter, type ReadonlyKysely, type RegisteredDB, type RegisteredRelations, Relation, RelationMany, type RelationMapEntry, RelationMorphOne, RelationMorphTo, RelationOne, type RelationSnapshot, RelationalQueryAliasCollisionError, RelationalQueryAmbiguousRelationNameError, RelationalQueryCancelledError, RelationalQueryDepthError, RelationalQueryMissingInverseError, RelationalQueryNotSupportedError, RelationalQueryThroughError, RelationalQueryUnknownRelationError, RelationsDecl, type RemoveEnumValue, RemovedValueAsDefaultError, type RenameCandidates, type RenameColumn, type RenameHints, type RenameTable, type ResolvedRelation, type ResolvedRelations, type ReversedSummary, type ReviewResult, type RollbackSummary, Rule, type RuleFor, type RunnerOptions, type SchemaDiffSummary, type SchemaSnapshot, type SchemaToRelationsRegister, type SchemaToTypes, type SeedFakeOptions, type SeedResult, type Selectable, SerializationFailureError, type SetColumnComment, type SetRowLevelSecurity, type SetTableComment, type Sql, type SqlBool, type SqliteIntrospectDb, SqliteRebuildRequiredError, type StatusEntry, type StringRule, TableBase, type TableClass, TableConstraint, TableDecl, TableDefinition, TableOptions, type TableQueryNamespace, type TableRelations, type TableSnapshot, Tenancy, TenancyOptions, TenancyStrategy, type TenantMigrationResult, TenantRequiredError, ThroughSpec, TimestampBuilder, type TransactionEvent, TransactionFinishedError, type TransactionOptions, type TransactionRetryEvent, type TransactionRollbackEvent, type TypedColumnRef, type TypedColumnRefs, UniqueViolationError, UnreviewedMigrationError, type Updateable, type UpsertOptions, UuidBuilder, ViewDecl, ViewMarks, ViewOptions, type WithClause, alias, and, appendJournalEntry, asc, between, bigSerial, bigint, boolean, buildTable, buildView, bytea, char, check, checkDrift, checkMigrations, computeMigrationHash, createDbClient, customType, date, decimal, defineTable, defineTenancy, desc, detectCompositeReferences, diff, doublePrecision, emitMysql, emitPg, emitSqlite, enforceEnumDropGate, eq, escapeLike, exists, extractSnapshot, fakeRows, findRenameCandidates, fitIdentifier, fk, generate, gt, gte, hasAmbiguousReverse, ilike, inArray, index, integer, interval, introspectMysql, introspectPg, introspectSqlite, introspectSqliteAsync, invertChanges, isDialectTag, isNotNull, isNull, isView, json, jsonb, kickDbAdapter, like, likePattern, link, listSeeds, lockTableDdl, lockTableName, lt, lte, markDialect, migrateDown, migrateLatest, migrateRollback, migrateStatus, migrateTenants, migrateUp, migrationFiles, migrationsTableDdl, ne, not, notExists, notInArray, notLike, numeric, or, parseEnumDropHeader, primaryKey, pushSchema, pushTableName, qualifiedTableName, quoteTable, readDialectMark, readJournal, real, relations, renderSchemaSource, resolveDbConfig, reviewMigration, runSeeds, safeNullComparison, seedFake, selfRef, serial, smallSerial, smallint, sql, table, tableFromClass, tenantKey, text, time, timestamp, timestamptz, toDbName, toKeyName, translateDbError, unique, unwrapTable, uuid, varchar, verifyMigrationHash, version, view };
package/dist/index.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @forinda/kickjs-db v8.12.4
2
+ * @forinda/kickjs-db v8.13.0
3
3
  *
4
4
  * Copyright (c) Felix Orinda
5
5
  *
@@ -8,4 +8,4 @@
8
8
  *
9
9
  * @license MIT
10
10
  */
11
- import{B as CheckViolationError,C as readJournal,Ct as unwrapTable,D as parseEnumDropHeader,Dt as fitIdentifier,E as enforceEnumDropGate,F as MigrationHashError,G as NotNullViolationError,H as DatabaseError,I as MigrationLockError,J as translateDbError,K as SerializationFailureError,L as UnreviewedMigrationError,M as MigrationEnumDropError,N as MigrationError,O as emitPg,P as MigrationFailedError,Q as extractSnapshot,R as TransactionFinishedError,S as computeMigrationHash,St as table,U as DeadlockError,V as ConnectionError,W as ForeignKeyViolationError,X as findRenameCandidates,Y as diff,_ as emitMysql,_t as buildView,a as markDialect,at as RelationalQueryDepthError,b as introspectPg,bt as buildTable,c as defineTenancy,ct as RelationalQueryThroughError,d as migrateLatest,dt as RemovedValueAsDefaultError,et as toDbName,f as migrateRollback,g as checkDrift,h as migrationFiles,i as isDialectTag,it as RelationalQueryCancelledError,j as MigrationDriftError,l as tenantKey,lt as RelationalQueryUnknownRelationError,m as migrateUp,n as KICK_DIALECT,nt as RelationalQueryAliasCollisionError,o as readDialectMark,ot as RelationalQueryMissingInverseError,p as migrateStatus,q as UniqueViolationError,rt as RelationalQueryAmbiguousRelationNameError,s as TenantRequiredError,st as RelationalQueryNotSupportedError,t as createDbClient,tt as toKeyName,u as migrateDown,ut as KickDbError,v as SqliteRebuildRequiredError,vt as isView,w as verifyMigrationHash,wt as selfRef,x as appendJournalEntry,xt as qualifiedTableName,y as emitSqlite,yt as view}from"./create-NrvNUwZr.mjs";import{$ as interval,A as index,At as introspectSqlite,Bt as CompositeEnumReferenceError,C as notExists,Ct as migrateTenants,D as alias,Dt as DB_REPLICA,E as or,Et as DB_PRIMARY,F as TableDefinition,Ft as lockTableDdl,G as bigint,H as TimestampBuilder,Ht as hasAmbiguousReverse,I as defineTable,It as lockTableName,J as char,K as boolean,L as fk,Lt as migrationsTableDdl,M as unique,Mt as MemoryMigrationAdapter,N as Rule,Nt as KICK_LOCK_TABLE,O as IndexDecl,Ot as kickDbAdapter,P as TableBase,Pt as KICK_MIGRATIONS_TABLE,Q as integer,R as link,Rt as pushTableName,S as not,St as reviewMigration,T as notLike,Tt as DB_CLIENT,U as UuidBuilder,Ut as invertChanges,Vt as detectCompositeReferences,W as bigSerial,Wt as renderSchemaSource,X as decimal,Y as date,Z as doublePrecision,_ as isNull,_t as runSeeds,a as escapeLike,at as smallSerial,b as lte,bt as pushSchema,c as and,ct as time,d as exists,dt as uuid,et as json,f as gt,ft as varchar,g as isNotNull,gt as listSeeds,h as inArray,ht as seedFake,i as desc,it as serial,j as primaryKey,jt as introspectSqliteAsync,k as check,kt as introspectMysql,l as between,lt as timestamp,m as ilike,mt as fakeRows,n as sql,nt as numeric,o as likePattern,ot as smallint,p as gte,pt as version,q as bytea,r as asc,rt as real,s as relations,st as text,t as Kysely,tt as jsonb,u as eq,ut as timestamptz,v as like,vt as checkMigrations,w as notInArray,wt as safeNullComparison,x as ne,xt as generate,y as lt,yt as resolveDbConfig,z as tableFromClass,zt as quoteTable}from"./src-BkewQb59.mjs";import{a as KICK_NOT_NULL,i as KICK_GENERATED,n as customType,r as ColumnBuilder,t as CustomColumnBuilder}from"./custom-type-CNmg8h4k.mjs";export{CheckViolationError,ColumnBuilder,CompositeEnumReferenceError,ConnectionError,CustomColumnBuilder,DB_CLIENT,DB_PRIMARY,DB_REPLICA,DatabaseError,DeadlockError,ForeignKeyViolationError,IndexDecl,KICK_DIALECT,KICK_GENERATED,KICK_LOCK_TABLE,KICK_MIGRATIONS_TABLE,KICK_NOT_NULL,KickDbError,Kysely,MemoryMigrationAdapter,MigrationDriftError,MigrationEnumDropError,MigrationError,MigrationFailedError,MigrationHashError,MigrationLockError,NotNullViolationError,RelationalQueryAliasCollisionError,RelationalQueryAmbiguousRelationNameError,RelationalQueryCancelledError,RelationalQueryDepthError,RelationalQueryMissingInverseError,RelationalQueryNotSupportedError,RelationalQueryThroughError,RelationalQueryUnknownRelationError,RemovedValueAsDefaultError,Rule,SerializationFailureError,SqliteRebuildRequiredError,TableBase,TableDefinition,TenantRequiredError,TimestampBuilder,TransactionFinishedError,UniqueViolationError,UnreviewedMigrationError,UuidBuilder,alias,and,appendJournalEntry,asc,between,bigSerial,bigint,boolean,buildTable,buildView,bytea,char,check,checkDrift,checkMigrations,computeMigrationHash,createDbClient,customType,date,decimal,defineTable,defineTenancy,desc,detectCompositeReferences,diff,doublePrecision,emitMysql,emitPg,emitSqlite,enforceEnumDropGate,eq,escapeLike,exists,extractSnapshot,fakeRows,findRenameCandidates,fitIdentifier,fk,generate,gt,gte,hasAmbiguousReverse,ilike,inArray,index,integer,interval,introspectMysql,introspectPg,introspectSqlite,introspectSqliteAsync,invertChanges,isDialectTag,isNotNull,isNull,isView,json,jsonb,kickDbAdapter,like,likePattern,link,listSeeds,lockTableDdl,lockTableName,lt,lte,markDialect,migrateDown,migrateLatest,migrateRollback,migrateStatus,migrateTenants,migrateUp,migrationFiles,migrationsTableDdl,ne,not,notExists,notInArray,notLike,numeric,or,parseEnumDropHeader,primaryKey,pushSchema,pushTableName,qualifiedTableName,quoteTable,readDialectMark,readJournal,real,relations,renderSchemaSource,resolveDbConfig,reviewMigration,runSeeds,safeNullComparison,seedFake,selfRef,serial,smallSerial,smallint,sql,table,tableFromClass,tenantKey,text,time,timestamp,timestamptz,toDbName,toKeyName,translateDbError,unique,unwrapTable,uuid,varchar,verifyMigrationHash,version,view};
11
+ import{B as CheckViolationError,C as readJournal,Ct as unwrapTable,D as parseEnumDropHeader,Dt as fitIdentifier,E as enforceEnumDropGate,F as MigrationHashError,G as NotNullViolationError,H as DatabaseError,I as MigrationLockError,J as translateDbError,K as SerializationFailureError,L as UnreviewedMigrationError,M as MigrationEnumDropError,N as MigrationError,O as emitPg,P as MigrationFailedError,Q as extractSnapshot,R as TransactionFinishedError,S as computeMigrationHash,St as table,U as DeadlockError,V as ConnectionError,W as ForeignKeyViolationError,X as findRenameCandidates,Y as diff,_ as emitMysql,_t as buildView,a as markDialect,at as RelationalQueryDepthError,b as introspectPg,bt as buildTable,c as defineTenancy,ct as RelationalQueryThroughError,d as migrateLatest,dt as RemovedValueAsDefaultError,et as toDbName,f as migrateRollback,g as checkDrift,h as migrationFiles,i as isDialectTag,it as RelationalQueryCancelledError,j as MigrationDriftError,l as tenantKey,lt as RelationalQueryUnknownRelationError,m as migrateUp,n as KICK_DIALECT,nt as RelationalQueryAliasCollisionError,o as readDialectMark,ot as RelationalQueryMissingInverseError,p as migrateStatus,q as UniqueViolationError,rt as RelationalQueryAmbiguousRelationNameError,s as TenantRequiredError,st as RelationalQueryNotSupportedError,t as createDbClient,tt as toKeyName,u as migrateDown,ut as KickDbError,v as SqliteRebuildRequiredError,vt as isView,w as verifyMigrationHash,wt as selfRef,x as appendJournalEntry,xt as qualifiedTableName,y as emitSqlite,yt as view}from"./create-BGFj2wGn.mjs";import{$ as interval,A as index,At as introspectSqlite,Bt as CompositeEnumReferenceError,C as notExists,Ct as migrateTenants,D as alias,Dt as DB_REPLICA,E as or,Et as DB_PRIMARY,F as TableDefinition,Ft as lockTableDdl,G as bigint,H as TimestampBuilder,Ht as hasAmbiguousReverse,I as defineTable,It as lockTableName,J as char,K as boolean,L as fk,Lt as migrationsTableDdl,M as unique,Mt as MemoryMigrationAdapter,N as Rule,Nt as KICK_LOCK_TABLE,O as IndexDecl,Ot as kickDbAdapter,P as TableBase,Pt as KICK_MIGRATIONS_TABLE,Q as integer,R as link,Rt as pushTableName,S as not,St as reviewMigration,T as notLike,Tt as DB_CLIENT,U as UuidBuilder,Ut as invertChanges,Vt as detectCompositeReferences,W as bigSerial,Wt as renderSchemaSource,X as decimal,Y as date,Z as doublePrecision,_ as isNull,_t as runSeeds,a as escapeLike,at as smallSerial,b as lte,bt as pushSchema,c as and,ct as time,d as exists,dt as uuid,et as json,f as gt,ft as varchar,g as isNotNull,gt as listSeeds,h as inArray,ht as seedFake,i as desc,it as serial,j as primaryKey,jt as introspectSqliteAsync,k as check,kt as introspectMysql,l as between,lt as timestamp,m as ilike,mt as fakeRows,n as sql,nt as numeric,o as likePattern,ot as smallint,p as gte,pt as version,q as bytea,r as asc,rt as real,s as relations,st as text,t as Kysely,tt as jsonb,u as eq,ut as timestamptz,v as like,vt as checkMigrations,w as notInArray,wt as safeNullComparison,x as ne,xt as generate,y as lt,yt as resolveDbConfig,z as tableFromClass,zt as quoteTable}from"./src-CBTegE76.mjs";import{a as KICK_NOT_NULL,i as KICK_GENERATED,n as customType,r as ColumnBuilder,t as CustomColumnBuilder}from"./custom-type-CyQYFrA5.mjs";export{CheckViolationError,ColumnBuilder,CompositeEnumReferenceError,ConnectionError,CustomColumnBuilder,DB_CLIENT,DB_PRIMARY,DB_REPLICA,DatabaseError,DeadlockError,ForeignKeyViolationError,IndexDecl,KICK_DIALECT,KICK_GENERATED,KICK_LOCK_TABLE,KICK_MIGRATIONS_TABLE,KICK_NOT_NULL,KickDbError,Kysely,MemoryMigrationAdapter,MigrationDriftError,MigrationEnumDropError,MigrationError,MigrationFailedError,MigrationHashError,MigrationLockError,NotNullViolationError,RelationalQueryAliasCollisionError,RelationalQueryAmbiguousRelationNameError,RelationalQueryCancelledError,RelationalQueryDepthError,RelationalQueryMissingInverseError,RelationalQueryNotSupportedError,RelationalQueryThroughError,RelationalQueryUnknownRelationError,RemovedValueAsDefaultError,Rule,SerializationFailureError,SqliteRebuildRequiredError,TableBase,TableDefinition,TenantRequiredError,TimestampBuilder,TransactionFinishedError,UniqueViolationError,UnreviewedMigrationError,UuidBuilder,alias,and,appendJournalEntry,asc,between,bigSerial,bigint,boolean,buildTable,buildView,bytea,char,check,checkDrift,checkMigrations,computeMigrationHash,createDbClient,customType,date,decimal,defineTable,defineTenancy,desc,detectCompositeReferences,diff,doublePrecision,emitMysql,emitPg,emitSqlite,enforceEnumDropGate,eq,escapeLike,exists,extractSnapshot,fakeRows,findRenameCandidates,fitIdentifier,fk,generate,gt,gte,hasAmbiguousReverse,ilike,inArray,index,integer,interval,introspectMysql,introspectPg,introspectSqlite,introspectSqliteAsync,invertChanges,isDialectTag,isNotNull,isNull,isView,json,jsonb,kickDbAdapter,like,likePattern,link,listSeeds,lockTableDdl,lockTableName,lt,lte,markDialect,migrateDown,migrateLatest,migrateRollback,migrateStatus,migrateTenants,migrateUp,migrationFiles,migrationsTableDdl,ne,not,notExists,notInArray,notLike,numeric,or,parseEnumDropHeader,primaryKey,pushSchema,pushTableName,qualifiedTableName,quoteTable,readDialectMark,readJournal,real,relations,renderSchemaSource,resolveDbConfig,reviewMigration,runSeeds,safeNullComparison,seedFake,selfRef,serial,smallSerial,smallint,sql,table,tableFromClass,tenantKey,text,time,timestamp,timestamptz,toDbName,toKeyName,translateDbError,unique,unwrapTable,uuid,varchar,verifyMigrationHash,version,view};
package/dist/mysql.d.mts CHANGED
@@ -1,8 +1,7 @@
1
1
 
2
- import { n as ColumnBuilder } from "./types-DB_xyeQT.mjs";
3
- import { ea as MigrationAdapter } from "./index-Nf43jLx4.mjs";
2
+ import { ea as MigrationAdapter } from "./index-AaU739CK.mjs";
3
+ import { n as ColumnBuilder } from "./types-D4x2u-EZ.mjs";
4
4
  import { Dialect } from "kysely";
5
- //#region src/adapters/mysql/adapter.d.ts
6
5
  /**
7
6
  * mysql2-shaped pool that `mysqlAdapter` consumes. Mirrors the
8
7
  * structural surface of `mysql2/promise`'s Pool. The adapter only
@@ -106,8 +105,6 @@ export declare function splitMysqlStatements(sql: string): string[];
106
105
  * in a follow-up that walks `information_schema`.
107
106
  */
108
107
  export declare function mysqlAdapter(opts: MysqlAdapterOptions): MigrationAdapter;
109
- //#endregion
110
- //#region src/adapters/mysql/dialect.d.ts
111
108
  export interface MysqlDialectOptions {
112
109
  /**
113
110
  * mysql2-compatible pool — `createPool(...)` from `mysql2/promise`, the
@@ -142,8 +139,6 @@ export interface MysqlDialectOptions {
142
139
  * ```
143
140
  */
144
141
  export declare function mysqlDialect(opts: MysqlDialectOptions): Dialect;
145
- //#endregion
146
- //#region src/dsl/columns/mysql.d.ts
147
142
  /**
148
143
  * A MySQL `ENUM`: `status: mysqlEnum('active', 'archived')`, typed as the
149
144
  * union of its values. The values keep their case.
@@ -163,5 +158,4 @@ export declare function datetime(fsp?: number): ColumnBuilder<Date>;
163
158
  * `unsigned(bigint({ mode: 'bigint' }))`. Its type and chain stay as they were.
164
159
  */
165
160
  export declare function unsigned<C extends ColumnBuilder<number> | ColumnBuilder<bigint> | ColumnBuilder<string>>(column: C): C;
166
- //#endregion
167
161
  //# sourceMappingURL=mysql.d.mts.map
@@ -1 +1 @@
1
- {"version":3,"file":"mysql.d.mts","names":["KyselyDialect"],"sources":["../src/adapters/mysql/adapter.ts","../src/adapters/mysql/dialect.ts","../src/dsl/columns/mysql.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAgCiB;EAIf,MAAM,aAAa,aAAa,iBAAiB,SAAS;EAC1D;;iBAGe;EAEf,MAAM,aAAa,aAAa,iBAAiB,SAAS;EAC1D,iBAAiB,QAAQ;EACzB,QAAQ;;iBAGO;;;;;EAKf;;;;;;EAMA,MAAM;;;;;;;EAON;;;;;;;iBAiBe;EACf;EACA;EACA;;;;;;;;;;;;;;;wBAgBc,kBAAkB,kBAAkB;;;;;;;;wBA4CpC,uBAAuB;;wBA+BvB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BrB,aAAa,MAAM,sBAAsB;;;iBCpMxC;;;;;EAKf,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BQ,aAAa,MAAM,sBAAsBA;;;;;;;wBCtCzC,gBAAgB,6CAC3B,QAAQ,IACV,cAAc;;wBAMD,WAAW;;wBAKX,aAAa;;;;;wBAQb,SAAS,eAAe,cAAc;;;;;wBAkBtC,SACd,UAAU,wBAAwB,wBAAwB,uBAC1D,QAAQ,IAAI"}
1
+ {"version":3,"file":"mysql.d.mts","names":["KyselyDialect"],"sources":["../src/adapters/mysql/adapter.ts","../src/adapters/mysql/dialect.ts","../src/dsl/columns/mysql.ts"],"mappings":";;;;;;;;;;;;;;;;;iBAgCiB;EAIf,MAAM,aAAa,aAAa,iBAAiB,SAAS;EAC1D;;iBAGe;EAEf,MAAM,aAAa,aAAa,iBAAiB,SAAS;EAC1D,iBAAiB,QAAQ;EACzB,QAAQ;;iBAGO;;;;;EAKf;;;;;;EAMA,MAAM;;;;;;;EAON;;;;;;;iBAiBe;EACf;EACA;EACA;;;;;;;;;;;;;;;wBAgBc,kBAAkB,kBAAkB;;;;;;;;wBA4CpC,uBAAuB;;wBA+BvB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BrB,aAAa,MAAM,sBAAsB;iBCpMxC;;;;;EAKf,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BQ,aAAa,MAAM,sBAAsBA;;;;;wBCtCzC,gBAAgB,6CAC3B,QAAQ,IACV,cAAc;;wBAMD,WAAW;;wBAKX,aAAa;;;;;wBAQb,SAAS,eAAe,cAAc;;;;;wBAkBtC,SACd,UAAU,wBAAwB,wBAAwB,uBAC1D,QAAQ,IAAI"}
package/dist/mysql.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @forinda/kickjs-db v8.12.4
2
+ * @forinda/kickjs-db v8.13.0
3
3
  *
4
4
  * Copyright (c) Felix Orinda
5
5
  *
@@ -8,7 +8,7 @@
8
8
  *
9
9
  * @license MIT
10
10
  */
11
- import{a as markDialect,r as KICK_DIALECT_DATES,ut as KickDbError}from"./create-NrvNUwZr.mjs";import{Ft as lockTableDdl,It as lockTableName,Lt as migrationsTableDdl,Rt as pushTableName,kt as introspectMysql,zt as quoteTable}from"./src-BkewQb59.mjs";import{r as ColumnBuilder}from"./custom-type-CNmg8h4k.mjs";import{t as splitSqlStatements}from"./split-statements-cNBnqF81.mjs";import{Kysely,MysqlDialect}from"kysely";function mysqlDialect(opts){let raw=opts.pool,callbackPool=typeof raw.pool?.getConnection==`function`?raw.pool:opts.pool,dialect=markDialect(new MysqlDialect({pool:callbackPool}),`mysql`),config=callbackPool.config?.connectionConfig,dates={timezone:config?.timezone??`local`,dateStrings:config?.dateStrings??!1};return Object.defineProperty(dialect,KICK_DIALECT_DATES,{value:dates,enumerable:!1}),dialect}function parseMysqlVersion(version){let trimmed=version.trim();if(/MariaDB/i.test(trimmed)){let m=/(\d+)\.(\d+)(?:\.\d+)?-MariaDB/i.exec(trimmed);if(m){let major=Number(m[1]),minor=Number(m[2]);if(Number.isFinite(major)&&Number.isFinite(minor))return{flavor:`mariadb`,major,minor}}let fallback=/^(\d+)\.(\d+)/.exec(trimmed);if(!fallback)return null;let major=Number(fallback[1]),minor=Number(fallback[2]);return!Number.isFinite(major)||!Number.isFinite(minor)?null:{flavor:`mariadb`,major,minor}}let m=/^(\d+)\.(\d+)/.exec(trimmed);if(!m)return null;let major=Number(m[1]),minor=Number(m[2]);return!Number.isFinite(major)||!Number.isFinite(minor)?null:{flavor:`mysql`,major,minor}}function parseMysqlMajorVersion(version){return parseMysqlVersion(version)?.major??null}function checkVersionSupport(parsed,raw){return parsed==null?`unparseable version string: ${raw||`<empty>`}`:parsed.flavor===`mariadb`?parsed.major>10?null:parsed.major<10||parsed.minor<5?`MariaDB 10.5+ required (detected: ${raw})`:null:parsed.major<8?`MySQL 8.0+ required (detected: ${raw})`:null}function splitMysqlStatements(sql){return splitSqlStatements(sql,`mysql`)}function mysqlAdapter(opts){if(opts.endPoolOnClose&&typeof opts.pool.end!=`function`)throw new KickDbError(`KICK_DB_POOL_NOT_CLOSABLE`,`mysqlAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close`);let dialect=`mysql`,{pool}=opts,versionVerified=!1;async function assertVersion(){if(versionVerified)return;let[rows]=await pool.query("SELECT VERSION() AS `version`"),versionString=rows[0]?.version??``,failure=checkVersionSupport(parseMysqlVersion(versionString),versionString);if(failure)throw new KickDbError(`KICK_DB_RELATIONAL_NOT_SUPPORTED`,`${failure}. JSON_ARRAYAGG (required by the relational query layer) shipped in MySQL 8.0 and MariaDB 10.5. Use layer-1/layer-2 queries (selectFrom / selectAll) on older versions.`);versionVerified=!0}async function runStatements(sql){for(let stmt of splitMysqlStatements(sql))await pool.query(stmt)}async function runStatementsOnConn(conn,sql){for(let stmt of splitMysqlStatements(sql))await conn.query(stmt)}let table=opts.migrationsTable??`kick_migrations`,T=quoteTable(dialect,table),L=quoteTable(dialect,lockTableName(table)),bookkeepingTables=[table,lockTableName(table),pushTableName(table)],migrationDb;return{dialect,async ensureMigrationTables(){await assertVersion(),await runStatements(migrationsTableDdl(dialect,table)),await runStatements(lockTableDdl(dialect,table))},async listApplied(){let[rows]=await pool.query(`SELECT id, name, hash, batch, applied_at, direction
11
+ import{t as splitSqlStatements}from"./split-statements-DHYNJs5X.mjs";import{a as markDialect,r as KICK_DIALECT_DATES,ut as KickDbError}from"./create-BGFj2wGn.mjs";import{Ft as lockTableDdl,It as lockTableName,Lt as migrationsTableDdl,Rt as pushTableName,kt as introspectMysql,zt as quoteTable}from"./src-CBTegE76.mjs";import{r as ColumnBuilder}from"./custom-type-CyQYFrA5.mjs";import{Kysely,MysqlDialect}from"kysely";function mysqlDialect(opts){let raw=opts.pool,callbackPool=typeof raw.pool?.getConnection==`function`?raw.pool:opts.pool,dialect=markDialect(new MysqlDialect({pool:callbackPool}),`mysql`),config=callbackPool.config?.connectionConfig,dates={timezone:config?.timezone??`local`,dateStrings:config?.dateStrings??!1};return Object.defineProperty(dialect,KICK_DIALECT_DATES,{value:dates,enumerable:!1}),dialect}function parseMysqlVersion(version){let trimmed=version.trim();if(/MariaDB/i.test(trimmed)){let m=/(\d+)\.(\d+)(?:\.\d+)?-MariaDB/i.exec(trimmed);if(m){let major=Number(m[1]),minor=Number(m[2]);if(Number.isFinite(major)&&Number.isFinite(minor))return{flavor:`mariadb`,major,minor}}let fallback=/^(\d+)\.(\d+)/.exec(trimmed);if(!fallback)return null;let major=Number(fallback[1]),minor=Number(fallback[2]);return!Number.isFinite(major)||!Number.isFinite(minor)?null:{flavor:`mariadb`,major,minor}}let m=/^(\d+)\.(\d+)/.exec(trimmed);if(!m)return null;let major=Number(m[1]),minor=Number(m[2]);return!Number.isFinite(major)||!Number.isFinite(minor)?null:{flavor:`mysql`,major,minor}}function parseMysqlMajorVersion(version){return parseMysqlVersion(version)?.major??null}function checkVersionSupport(parsed,raw){return parsed==null?`unparseable version string: ${raw||`<empty>`}`:parsed.flavor===`mariadb`?parsed.major>10?null:parsed.major<10||parsed.minor<5?`MariaDB 10.5+ required (detected: ${raw})`:null:parsed.major<8?`MySQL 8.0+ required (detected: ${raw})`:null}function splitMysqlStatements(sql){return splitSqlStatements(sql,`mysql`)}function mysqlAdapter(opts){if(opts.endPoolOnClose&&typeof opts.pool.end!=`function`)throw new KickDbError(`KICK_DB_POOL_NOT_CLOSABLE`,`mysqlAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close`);let dialect=`mysql`,{pool}=opts,versionVerified=!1;async function assertVersion(){if(versionVerified)return;let[rows]=await pool.query("SELECT VERSION() AS `version`"),versionString=rows[0]?.version??``,failure=checkVersionSupport(parseMysqlVersion(versionString),versionString);if(failure)throw new KickDbError(`KICK_DB_RELATIONAL_NOT_SUPPORTED`,`${failure}. JSON_ARRAYAGG (required by the relational query layer) shipped in MySQL 8.0 and MariaDB 10.5. Use layer-1/layer-2 queries (selectFrom / selectAll) on older versions.`);versionVerified=!0}async function runStatements(sql){for(let stmt of splitMysqlStatements(sql))await pool.query(stmt)}async function runStatementsOnConn(conn,sql){for(let stmt of splitMysqlStatements(sql))await conn.query(stmt)}let table=opts.migrationsTable??`kick_migrations`,T=quoteTable(dialect,table),L=quoteTable(dialect,lockTableName(table)),bookkeepingTables=[table,lockTableName(table),pushTableName(table)],migrationDb;return{dialect,async ensureMigrationTables(){await assertVersion(),await runStatements(migrationsTableDdl(dialect,table)),await runStatements(lockTableDdl(dialect,table))},async listApplied(){let[rows]=await pool.query(`SELECT id, name, hash, batch, applied_at, direction
12
12
  FROM ${T}
13
13
  ORDER BY applied_at ASC, id ASC`);return rows.map(row=>({id:row.id,name:row.name,hash:row.hash,batch:Number(row.batch),appliedAt:row.applied_at instanceof Date?row.applied_at.toISOString():String(row.applied_at),direction:row.direction}))},async recordApplied(row){await pool.query(`INSERT INTO ${T} (id, name, hash, batch, direction)
14
14
  VALUES (?, ?, ?, ?, ?)`,[row.id,row.name,row.hash,row.batch,row.direction])},async removeApplied(id){await pool.query(`DELETE FROM ${T} WHERE id = ?`,[id])},async acquireLock(owner,staleAfterSeconds){let[result]=await pool.query(staleAfterSeconds===void 0?`UPDATE ${L}
@@ -1 +1 @@
1
- {"version":3,"file":"mysql.mjs","names":[],"sources":["../src/adapters/mysql/dialect.ts","../src/adapters/mysql/adapter.ts","../src/dsl/columns/mysql.ts"],"sourcesContent":["// mysqlDialect — thin factory over Kysely's MysqlDialect so adopters\n// never have to reach for `import { MysqlDialect } from 'kysely'`.\n// Mirrors the `@forinda/kickjs-db/pg` template; the kysely subpackage\n// is a pinned internal dep of the framework.\n\nimport { MysqlDialect, type Dialect as KyselyDialect } from 'kysely'\nimport { KICK_DIALECT_DATES, markDialect, type DialectDateOptions } from '../../dialect-marker'\n\nimport type { MysqlPoolLike } from './adapter'\n\nexport interface MysqlDialectOptions {\n /**\n * mysql2-compatible pool — `createPool(...)` from `mysql2/promise`, the\n * same pool `mysqlAdapter` takes. A callback-API pool works too.\n */\n pool: MysqlPoolLike\n}\n\n/**\n * Construct the dialect that `createDbClient({ dialect })` consumes.\n *\n * **MySQL 8.0+ required.** Kickjs-db's relational query layer\n * compiles to `JSON_ARRAYAGG`, which shipped in 8.0. Adapter-side\n * version assertion lands at first connection from `mysqlAdapter()`;\n * see that factory's docs.\n *\n * @example\n * ```ts\n * import { createDbClient } from '@forinda/kickjs-db'\n * import { mysqlAdapter, mysqlDialect } from '@forinda/kickjs-db/mysql'\n * import { createPool } from 'mysql2/promise'\n *\n * const pool = createPool({\n * host: '127.0.0.1', user: 'root', password: '...', database: 'app',\n * })\n *\n * export const db = createDbClient({\n * schema,\n * dialect: mysqlDialect({ pool }),\n * })\n *\n * export const migrationAdapter = mysqlAdapter({ pool })\n * ```\n */\nexport function mysqlDialect(opts: MysqlDialectOptions): KyselyDialect {\n // MysqlDialect's `pool` parameter is typed as `mysql2.Pool` in\n // newer Kysely versions; casting through `unknown` keeps adopters\n // using compatible drivers (e.g. mysql-mariadb forks) working\n // without pulling mysql2's typings into our public surface.\n // Kysely's MysqlDialect drives the callback API (`getConnection(cb)`). A\n // `mysql2/promise` pool ignores the callback, so every query hung; its\n // callback-API core is `pool.pool` — hand Kysely that.\n const raw = opts.pool as unknown as { pool?: { getConnection?: unknown } }\n const callbackPool = typeof raw.pool?.getConnection === 'function' ? raw.pool : opts.pool\n const dialect = markDialect(new MysqlDialect({ pool: callbackPool as unknown as never }), 'mysql')\n // Rows nested by `db.query` carry dates as strings; read them the way\n // mysql2 reads top-level ones — in the pool's time zone, and not at all\n // for the types `dateStrings` keeps as strings.\n type Cfg = { timezone?: string; dateStrings?: boolean | string[] }\n const config = (callbackPool as { config?: { connectionConfig?: Cfg } }).config?.connectionConfig\n const dates: DialectDateOptions = {\n timezone: config?.timezone ?? 'local',\n dateStrings: config?.dateStrings ?? false,\n }\n Object.defineProperty(dialect, KICK_DIALECT_DATES, { value: dates, enumerable: false })\n return dialect\n}\n","import { Kysely } from 'kysely'\nimport { splitSqlStatements } from '../../migrate/split-statements'\nimport { mysqlDialect } from './dialect'\nimport {\n KickDbError,\n lockTableDdl,\n lockTableName,\n pushTableName,\n quoteTable,\n KICK_MIGRATIONS_TABLE,\n migrationsTableDdl,\n type Dialect,\n type MigrationAdapter,\n type MigrationBookkeeping,\n type MigrationRow,\n type SchemaSnapshot,\n} from '../../index'\nimport { introspectMysql } from '../../migrate/introspect-mysql'\n\n/**\n * mysql2-shaped pool that `mysqlAdapter` consumes. Mirrors the\n * structural surface of `mysql2/promise`'s Pool. The adapter only\n * uses `query(...)` and `getConnection(...)` so any mysql2-compatible\n * driver works.\n *\n * Return type is `Promise<[R, unknown]>` (not `[R[], unknown]`) so\n * mysql2's `Pool.query()` is structurally assignable: SELECT\n * statements return `RowDataPacket[]` (so callers pass `R =\n * MyRow[]`), INSERT / UPDATE / DELETE return `ResultSetHeader` (so\n * callers pass `R = ResultSetHeader`). Each adapter call site picks\n * the row shape it expects via the type parameter.\n */\nexport interface MysqlConnectionLike {\n // `any[]`, not `readonly unknown[]`: mysql2 declares its values parameter\n // mutable, and a readonly one here made a real mysql2 Pool unassignable.\n // oxlint-disable-next-line no-explicit-any\n query<R = unknown>(sql: string, params?: any[]): Promise<[R, unknown]>\n release(): void\n}\n\nexport interface MysqlPoolLike {\n // oxlint-disable-next-line no-explicit-any\n query<R = unknown>(sql: string, params?: any[]): Promise<[R, unknown]>\n getConnection(): Promise<MysqlConnectionLike>\n end?(): Promise<void>\n}\n\nexport interface MysqlAdapterOptions {\n /**\n * The table migrations are recorded in. Default `kick_migrations`; its lock\n * table is the same name plus `_lock`.\n */\n migrationsTable?: string\n /**\n * mysql2-compatible Pool. Caller-owned — `close()` on the adapter\n * does NOT end the pool because adopters typically share a single\n * pool across the migration adapter and the KickDbClient.\n */\n pool: MysqlPoolLike\n /**\n * End the pool when the adapter closes. Set it when the adapter owns its\n * pool — a `kick.config.ts` `db.adapter()` factory that opens one for the\n * CLI — or the `kick db` command never exits. Default `false`: an app\n * usually shares one pool with its client.\n */\n endPoolOnClose?: boolean\n}\n\n/**\n * Minimum supported MySQL major + MariaDB version. `JSON_ARRAYAGG`\n * shipped in MySQL 8.0 and MariaDB 10.5 — earlier versions can't\n * run kickjs-db's relational query layer.\n */\nconst MIN_MYSQL_MAJOR = 8\nconst MIN_MARIADB_MAJOR = 10\nconst MIN_MARIADB_MINOR = 5\n\n/**\n * Parsed shape returned by `parseMysqlVersion`. `flavor` lets\n * adopters distinguish MySQL from MariaDB without re-grepping the\n * raw string.\n */\nexport interface ParsedMysqlVersion {\n flavor: 'mysql' | 'mariadb'\n major: number\n minor: number\n}\n\n/**\n * Parse a MySQL `SELECT VERSION()` string. Handles:\n *\n * - MySQL: `8.0.34`, `8.4.0`, `5.7.42-log`\n * - MariaDB plain: `10.6.11-MariaDB`, `10.5.21-MariaDB-log`,\n * `10.4.32-MariaDB`\n * - MariaDB w/ compat prefix: `5.5.5-10.6.11-MariaDB-1:10.6.11+maria~ubu2004`\n * (the leading `5.5.5-` is a wire-protocol thing for older MySQL\n * clients; the real server version sits immediately before\n * `-MariaDB`)\n *\n * Returns `null` on unparseable input.\n */\nexport function parseMysqlVersion(version: string): ParsedMysqlVersion | null {\n const trimmed = version.trim()\n const isMariaDb = /MariaDB/i.test(trimmed)\n\n if (isMariaDb) {\n // Pull the `major.minor` that sits immediately before\n // `-MariaDB`. This skips the `5.5.5-` compat prefix when\n // present and grabs the real server version regardless of\n // whether one's there.\n const m = /(\\d+)\\.(\\d+)(?:\\.\\d+)?-MariaDB/i.exec(trimmed)\n if (m) {\n const major = Number(m[1])\n const minor = Number(m[2])\n if (Number.isFinite(major) && Number.isFinite(minor)) {\n return { flavor: 'mariadb', major, minor }\n }\n }\n // Fallback for vendor strings we haven't seen — try the\n // leading x.y. Better to surface the wrong floor than to\n // refuse an otherwise valid MariaDB outright.\n const fallback = /^(\\d+)\\.(\\d+)/.exec(trimmed)\n if (!fallback) return null\n const major = Number(fallback[1])\n const minor = Number(fallback[2])\n if (!Number.isFinite(major) || !Number.isFinite(minor)) return null\n return { flavor: 'mariadb', major, minor }\n }\n\n // MySQL: leading x.y from the start of the string.\n const m = /^(\\d+)\\.(\\d+)/.exec(trimmed)\n if (!m) return null\n const major = Number(m[1])\n const minor = Number(m[2])\n if (!Number.isFinite(major) || !Number.isFinite(minor)) return null\n return { flavor: 'mysql', major, minor }\n}\n\n/**\n * Back-compat shim — pre-existing API surface that returned the\n * major version only. Kept exported so adopters depending on it\n * keep working; new code should use `parseMysqlVersion`.\n *\n * @deprecated Use `parseMysqlVersion` for full version + flavor info.\n */\nexport function parseMysqlMajorVersion(version: string): number | null {\n const parsed = parseMysqlVersion(version)\n return parsed?.major ?? null\n}\n\n/**\n * Returns the failure reason if the parsed version doesn't satisfy\n * kickjs-db's floor, or `null` if it does. Pure — no I/O.\n */\nfunction checkVersionSupport(parsed: ParsedMysqlVersion | null, raw: string): string | null {\n if (parsed == null) {\n return `unparseable version string: ${raw || '<empty>'}`\n }\n if (parsed.flavor === 'mariadb') {\n if (parsed.major > MIN_MARIADB_MAJOR) return null\n if (parsed.major < MIN_MARIADB_MAJOR) {\n return `MariaDB ${MIN_MARIADB_MAJOR}.${MIN_MARIADB_MINOR}+ required (detected: ${raw})`\n }\n if (parsed.minor < MIN_MARIADB_MINOR) {\n return `MariaDB ${MIN_MARIADB_MAJOR}.${MIN_MARIADB_MINOR}+ required (detected: ${raw})`\n }\n return null\n }\n // MySQL flavor.\n if (parsed.major < MIN_MYSQL_MAJOR) {\n return `MySQL ${MIN_MYSQL_MAJOR}.0+ required (detected: ${raw})`\n }\n return null\n}\n\n/** {@link splitSqlStatements} for MySQL. */\nexport function splitMysqlStatements(sql: string): string[] {\n return splitSqlStatements(sql, 'mysql')\n}\n\n/**\n * MigrationAdapter implementation backed by mysql2.\n *\n * Asserts MySQL 8.0+ (or MariaDB 10.5+) on first connection (via\n * the first `ensureMigrationTables` call, lazily — no I/O at\n * construction time). Earlier versions throw `KickDbError` with\n * code `KICK_DB_RELATIONAL_NOT_SUPPORTED` carrying the detected\n * version so adopters get a clear error before any query reaches\n * the relational compiler.\n *\n * Multi-statement support: every `query()` call splits the SQL\n * blob at top-level semicolons and runs each statement\n * sequentially. Works against mysql2's default settings; adopters\n * who set `multipleStatements: true` on the pool pay no extra\n * cost (the split is cheap on small DDL blobs).\n *\n * Lock semantics: single-row UPDATE WHERE locked_at IS NULL on\n * `kick_migrations_lock`. Only the row created by\n * `ensureMigrationTables()` exists, so the UPDATE either flips\n * `locked_at` and returns `affectedRows=1` (we won) or matches\n * zero rows (someone else holds it).\n *\n * Introspection: not implemented in v1 — throws `KickDbError` with\n * code `KICK_DB_INTROSPECT_NOT_SUPPORTED`. Drift detection lands\n * in a follow-up that walks `information_schema`.\n */\nexport function mysqlAdapter(opts: MysqlAdapterOptions): MigrationAdapter {\n if (opts.endPoolOnClose && typeof opts.pool.end !== 'function') {\n throw new KickDbError(\n 'KICK_DB_POOL_NOT_CLOSABLE',\n 'mysqlAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close',\n )\n }\n const dialect: Dialect = 'mysql'\n const { pool } = opts\n let versionVerified = false\n\n async function assertVersion() {\n if (versionVerified) return\n const [rows] = await pool.query<{ version: string }[]>(`SELECT VERSION() AS \\`version\\``)\n const versionString = rows[0]?.version ?? ''\n const parsed = parseMysqlVersion(versionString)\n const failure = checkVersionSupport(parsed, versionString)\n if (failure) {\n throw new KickDbError(\n 'KICK_DB_RELATIONAL_NOT_SUPPORTED',\n `${failure}. JSON_ARRAYAGG (required by the relational query layer) shipped in ` +\n `MySQL 8.0 and MariaDB 10.5. Use layer-1/layer-2 queries (selectFrom / selectAll) ` +\n `on older versions.`,\n )\n }\n versionVerified = true\n }\n\n /**\n * Run a (possibly multi-statement) SQL blob via the pool,\n * splitting at top-level `;` so default mysql2 settings work.\n */\n async function runStatements(sql: string): Promise<void> {\n for (const stmt of splitMysqlStatements(sql)) {\n await pool.query(stmt)\n }\n }\n\n /**\n * Same as `runStatements` but on a held connection (used inside\n * `applySqlInTx` so all statements share the BEGIN / COMMIT\n * boundary).\n */\n async function runStatementsOnConn(conn: MysqlConnectionLike, sql: string): Promise<void> {\n for (const stmt of splitMysqlStatements(sql)) {\n await conn.query(stmt)\n }\n }\n\n const table = opts.migrationsTable ?? KICK_MIGRATIONS_TABLE\n const T = quoteTable(dialect, table)\n const L = quoteTable(dialect, lockTableName(table))\n // Introspection must not report the bookkeeping tables as schema.\n // A dot is part of the name here, not a schema.\n const bookkeepingTables = [table, lockTableName(table), pushTableName(table)]\n let migrationDb: Kysely<any> | undefined\n return {\n dialect,\n\n async ensureMigrationTables() {\n await assertVersion()\n await runStatements(migrationsTableDdl(dialect, table))\n await runStatements(lockTableDdl(dialect, table))\n },\n\n async listApplied(): Promise<MigrationRow[]> {\n const [rows] = await pool.query<\n Array<{\n id: string\n name: string\n hash: string\n batch: number\n applied_at: string | Date\n direction: 'up' | 'down'\n }>\n >(\n `SELECT id, name, hash, batch, applied_at, direction\n FROM ${T}\n ORDER BY applied_at ASC, id ASC`,\n )\n return rows.map((row) => ({\n id: row.id,\n name: row.name,\n hash: row.hash,\n batch: Number(row.batch),\n appliedAt:\n row.applied_at instanceof Date ? row.applied_at.toISOString() : String(row.applied_at),\n direction: row.direction,\n }))\n },\n\n async recordApplied(row) {\n await pool.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES (?, ?, ?, ?, ?)`,\n [row.id, row.name, row.hash, row.batch, row.direction],\n )\n },\n\n async removeApplied(id: string) {\n await pool.query(`DELETE FROM ${T} WHERE id = ?`, [id])\n },\n\n async acquireLock(owner: string, staleAfterSeconds?: number): Promise<boolean> {\n const [result] = await pool.query<{ affectedRows: number }>(\n staleAfterSeconds === undefined\n ? `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = ?\n WHERE id = 1 AND locked_at IS NULL`\n : `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = ?\n WHERE id = 1 AND (locked_at IS NULL OR locked_at < CURRENT_TIMESTAMP - INTERVAL ? SECOND)`,\n staleAfterSeconds === undefined ? [owner] : [owner, staleAfterSeconds],\n )\n return result.affectedRows === 1\n },\n\n async refreshLock(owner: string) {\n // mysql2 reports matched rows (FOUND_ROWS), so a refresh in the same second still counts.\n const [result] = await pool.query<{ affectedRows: number }>(\n `UPDATE ${L} SET locked_at = CURRENT_TIMESTAMP WHERE id = 1 AND locked_by = ?`,\n [owner],\n )\n return result.affectedRows === 1\n },\n\n async releaseLock(owner?: string) {\n await pool.query(\n `UPDATE ${L}\n SET locked_at = NULL, locked_by = NULL\n WHERE id = 1 AND (? IS NULL OR locked_by = ?)`,\n [owner ?? null, owner ?? null],\n )\n },\n\n async lockHolder() {\n const [rows] = await pool.query<{ locked_by: string | null }[]>(\n `SELECT locked_by FROM ${L} WHERE id = 1 AND locked_at IS NOT NULL`,\n )\n return rows[0]?.locked_by ?? null\n },\n\n async applySqlInTx(sql: string) {\n await this.applyMigrationInTx!(sql, null)\n },\n\n // MySQL commits DDL as it runs (an implicit COMMIT that ends this\n // transaction), so for a migration with DDL this is not atomic: the\n // schema change is committed before the bookkeeping row is written, and a\n // crash in between leaves it applied but unrecorded. Only a migration of\n // plain DML statements commits with its row.\n async applyMigrationInTx(sql: string, bookkeeping: MigrationBookkeeping | null) {\n const conn = await pool.getConnection()\n try {\n await conn.query('START TRANSACTION')\n await runStatementsOnConn(conn, sql)\n if (bookkeeping && 'record' in bookkeeping) {\n const r = bookkeeping.record\n await conn.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES (?, ?, ?, ?, ?)`,\n [r.id, r.name, r.hash, r.batch, r.direction],\n )\n } else if (bookkeeping) {\n await conn.query(`DELETE FROM ${T} WHERE id = ?`, [bookkeeping.remove])\n }\n await conn.query('COMMIT')\n } catch (err) {\n await conn.query('ROLLBACK').catch(() => {\n // Swallow rollback errors; we're already throwing the original.\n })\n throw err\n } finally {\n conn.release()\n }\n },\n\n async applySqlNoTx(sql: string) {\n await runStatements(sql)\n },\n\n async introspect(): Promise<SchemaSnapshot> {\n // Reverse-engineer the live schema via information_schema. Types come\n // back as the declared COLUMN_TYPE (a code-first `uuid()` reads as\n // `char(36)`), so this powers `kick db introspect`; byte-exact drift\n // against a code-first snapshot needs a dialect-normalised compare.\n return introspectMysql(pool, { excludeTables: bookkeepingTables })\n },\n\n migrationsTable: table,\n\n kysely() {\n // Built once, on the same connection. Never destroyed here: the pool or\n // handle belongs to the caller (or to close()).\n return (migrationDb ??= new Kysely<any>({\n dialect: mysqlDialect({ pool: opts.pool as never }),\n }))\n },\n\n async close() {\n // The caller owns the pool unless it said otherwise — adopters\n // typically share it with the KickDbClient.\n if (opts.endPoolOnClose) await pool.end?.()\n },\n }\n}\n","import { ColumnBuilder } from './types'\n\n/**\n * A MySQL `ENUM`: `status: mysqlEnum('active', 'archived')`, typed as the\n * union of its values. The values keep their case.\n */\nexport function mysqlEnum<const V extends readonly [string, ...string[]]>(\n ...values: V\n): ColumnBuilder<V[number]> {\n const quoted = values.map((v) => `'${v.replace(/'/g, \"''\")}'`).join(',')\n return new ColumnBuilder<V[number]>(`enum(${quoted})`)\n}\n\n/** A 1-byte integer (`TINYINT`, -128…127; 0…255 with {@link unsigned}). */\nexport function tinyint(): ColumnBuilder<number> {\n return new ColumnBuilder<number>('tinyint')\n}\n\n/** A 3-byte integer (`MEDIUMINT`). */\nexport function mediumint(): ColumnBuilder<number> {\n return new ColumnBuilder<number>('mediumint')\n}\n\n/**\n * `DATETIME`, with fractional seconds when given: `datetime(3)`. Unlike\n * `TIMESTAMP` it isn't converted to UTC, and it holds years 1000–9999.\n */\nexport function datetime(fsp?: number): ColumnBuilder<Date> {\n return new ColumnBuilder<Date>(fsp === undefined ? 'datetime' : `datetime(${fsp})`)\n}\n\n/** MySQL's spelling of each integer column type kick/db has. */\nconst INTEGER_TYPES: Record<string, string> = {\n tinyint: 'tinyint',\n smallint: 'smallint',\n mediumint: 'mediumint',\n integer: 'int',\n int: 'int',\n bigint: 'bigint',\n}\n\n/**\n * Make an integer column `UNSIGNED`: `unsigned(integer())`,\n * `unsigned(bigint({ mode: 'bigint' }))`. Its type and chain stay as they were.\n */\nexport function unsigned<\n C extends ColumnBuilder<number> | ColumnBuilder<bigint> | ColumnBuilder<string>,\n>(column: C): C {\n const state = (column as unknown as { state: { type: string } }).state\n const base = INTEGER_TYPES[state.type]\n if (!base) {\n throw new Error(`unsigned(): ${state.type} isn't an integer column`)\n }\n state.type = `${base} unsigned`\n return column\n}\n"],"mappings":";;;;;;;;;;iaA4CA,SAAgB,aAAa,KAA0C,CAQrE,IAAM,IAAM,KAAK,KACX,aAAe,OAAO,IAAI,MAAM,eAAkB,WAAa,IAAI,KAAO,KAAK,KAC/E,QAAU,YAAY,IAAI,aAAa,CAAE,KAAM,YAAiC,CAAC,EAAG,OAAO,EAK3F,OAAU,aAAyD,QAAQ,iBAC3E,MAA4B,CAChC,SAAU,QAAQ,UAAY,QAC9B,YAAa,QAAQ,aAAe,EACtC,EAEA,OADA,OAAO,eAAe,QAAS,mBAAoB,CAAE,MAAO,MAAO,WAAY,EAAM,CAAC,EAC/E,OACT,CCmCA,SAAgB,kBAAkB,QAA4C,CAC5E,IAAM,QAAU,QAAQ,KAAK,EAG7B,GAFkB,WAAW,KAAK,OAEtB,EAAG,CAKb,IAAM,EAAI,kCAAkC,KAAK,OAAO,EACxD,GAAI,EAAG,CACL,IAAM,MAAQ,OAAO,EAAE,EAAE,EACnB,MAAQ,OAAO,EAAE,EAAE,EACzB,GAAI,OAAO,SAAS,KAAK,GAAK,OAAO,SAAS,KAAK,EACjD,MAAO,CAAE,OAAQ,UAAW,MAAO,KAAM,CAE7C,CAIA,IAAM,SAAW,gBAAgB,KAAK,OAAO,EAC7C,GAAI,CAAC,SAAU,OAAO,KACtB,IAAM,MAAQ,OAAO,SAAS,EAAE,EAC1B,MAAQ,OAAO,SAAS,EAAE,EAEhC,MADI,CAAC,OAAO,SAAS,KAAK,GAAK,CAAC,OAAO,SAAS,KAAK,EAAU,KACxD,CAAE,OAAQ,UAAW,MAAO,KAAM,CAC3C,CAGA,IAAM,EAAI,gBAAgB,KAAK,OAAO,EACtC,GAAI,CAAC,EAAG,OAAO,KACf,IAAM,MAAQ,OAAO,EAAE,EAAE,EACnB,MAAQ,OAAO,EAAE,EAAE,EAEzB,MADI,CAAC,OAAO,SAAS,KAAK,GAAK,CAAC,OAAO,SAAS,KAAK,EAAU,KACxD,CAAE,OAAQ,QAAS,MAAO,KAAM,CACzC,CASA,SAAgB,uBAAuB,QAAgC,CAErE,OADe,kBAAkB,OACrB,CAAC,EAAE,OAAS,IAC1B,CAMA,SAAS,oBAAoB,OAAmC,IAA4B,CAkB1F,OAjBI,QAAU,KACL,+BAA+B,KAAO,YAE3C,OAAO,SAAW,UAChB,OAAO,MAAQ,GAA0B,KACzC,OAAO,MAAQ,IAGf,OAAO,MAAQ,EACV,qCAA0E,IAAI,GAEhF,KAGL,OAAO,MAAQ,EACV,kCAAmD,IAAI,GAEzD,IACT,CAGA,SAAgB,qBAAqB,IAAuB,CAC1D,OAAO,mBAAmB,IAAK,OAAO,CACxC,CA4BA,SAAgB,aAAa,KAA6C,CACxE,GAAI,KAAK,gBAAkB,OAAO,KAAK,KAAK,KAAQ,WAClD,MAAM,IAAI,YACR,4BACA,mFACF,EAEF,IAAM,QAAmB,QACnB,CAAE,MAAS,KACb,gBAAkB,GAEtB,eAAe,eAAgB,CAC7B,GAAI,gBAAiB,OACrB,GAAM,CAAC,MAAQ,MAAM,KAAK,MAA6B,+BAAiC,EAClF,cAAgB,KAAK,EAAE,EAAE,SAAW,GAEpC,QAAU,oBADD,kBAAkB,aACQ,EAAG,aAAa,EACzD,GAAI,QACF,MAAM,IAAI,YACR,mCACA,GAAG,QAAQ,wKAGb,EAEF,gBAAkB,EACpB,CAMA,eAAe,cAAc,IAA4B,CACvD,IAAK,IAAM,QAAQ,qBAAqB,GAAG,EACzC,MAAM,KAAK,MAAM,IAAI,CAEzB,CAOA,eAAe,oBAAoB,KAA2B,IAA4B,CACxF,IAAK,IAAM,QAAQ,qBAAqB,GAAG,EACzC,MAAM,KAAK,MAAM,IAAI,CAEzB,CAEA,IAAM,MAAQ,KAAK,iBAAA,kBACb,EAAI,WAAW,QAAS,KAAK,EAC7B,EAAI,WAAW,QAAS,cAAc,KAAK,CAAC,EAG5C,kBAAoB,CAAC,MAAO,cAAc,KAAK,EAAG,cAAc,KAAK,CAAC,EACxE,YACJ,MAAO,CACL,QAEA,MAAM,uBAAwB,CAC5B,MAAM,cAAc,EACpB,MAAM,cAAc,mBAAmB,QAAS,KAAK,CAAC,EACtD,MAAM,cAAc,aAAa,QAAS,KAAK,CAAC,CAClD,EAEA,MAAM,aAAuC,CAC3C,GAAM,CAAC,MAAQ,MAAM,KAAK,MAUxB;gBACQ,EAAE;yCAEZ,EACA,OAAO,KAAK,IAAK,MAAS,CACxB,GAAI,IAAI,GACR,KAAM,IAAI,KACV,KAAM,IAAI,KACV,MAAO,OAAO,IAAI,KAAK,EACvB,UACE,IAAI,sBAAsB,KAAO,IAAI,WAAW,YAAY,EAAI,OAAO,IAAI,UAAU,EACvF,UAAW,IAAI,SACjB,EAAE,CACJ,EAEA,MAAM,cAAc,IAAK,CACvB,MAAM,KAAK,MACT,eAAe,EAAE;iCAEjB,CAAC,IAAI,GAAI,IAAI,KAAM,IAAI,KAAM,IAAI,MAAO,IAAI,SAAS,CACvD,CACF,EAEA,MAAM,cAAc,GAAY,CAC9B,MAAM,KAAK,MAAM,eAAe,EAAE,eAAgB,CAAC,EAAE,CAAC,CACxD,EAEA,MAAM,YAAY,MAAe,kBAA8C,CAC7E,GAAM,CAAC,QAAU,MAAM,KAAK,MAC1B,oBAAsB,IAAA,GAClB,UAAU,EAAE;;iDAGZ,UAAU,EAAE;;wGAGhB,oBAAsB,IAAA,GAAY,CAAC,KAAK,EAAI,CAAC,MAAO,iBAAiB,CACvE,EACA,OAAO,OAAO,eAAiB,CACjC,EAEA,MAAM,YAAY,MAAe,CAE/B,GAAM,CAAC,QAAU,MAAM,KAAK,MAC1B,UAAU,EAAE,mEACZ,CAAC,KAAK,CACR,EACA,OAAO,OAAO,eAAiB,CACjC,EAEA,MAAM,YAAY,MAAgB,CAChC,MAAM,KAAK,MACT,UAAU,EAAE;;wDAGZ,CAAC,OAAS,KAAM,OAAS,IAAI,CAC/B,CACF,EAEA,MAAM,YAAa,CACjB,GAAM,CAAC,MAAQ,MAAM,KAAK,MACxB,yBAAyB,EAAE,wCAC7B,EACA,OAAO,KAAK,EAAE,EAAE,WAAa,IAC/B,EAEA,MAAM,aAAa,IAAa,CAC9B,MAAM,KAAK,mBAAoB,IAAK,IAAI,CAC1C,EAOA,MAAM,mBAAmB,IAAa,YAA0C,CAC9E,IAAM,KAAO,MAAM,KAAK,cAAc,EACtC,GAAI,CAGF,GAFA,MAAM,KAAK,MAAM,mBAAmB,EACpC,MAAM,oBAAoB,KAAM,GAAG,EAC/B,aAAe,WAAY,YAAa,CAC1C,IAAM,EAAI,YAAY,OACtB,MAAM,KAAK,MACT,eAAe,EAAE;qCAEjB,CAAC,EAAE,GAAI,EAAE,KAAM,EAAE,KAAM,EAAE,MAAO,EAAE,SAAS,CAC7C,CACF,MAAW,aACT,MAAM,KAAK,MAAM,eAAe,EAAE,eAAgB,CAAC,YAAY,MAAM,CAAC,EAExE,MAAM,KAAK,MAAM,QAAQ,CAC3B,OAAS,IAAK,CAIZ,MAHA,MAAM,KAAK,MAAM,UAAU,CAAC,CAAC,UAAY,CAEzC,CAAC,EACK,GACR,QAAU,CACR,KAAK,QAAQ,CACf,CACF,EAEA,MAAM,aAAa,IAAa,CAC9B,MAAM,cAAc,GAAG,CACzB,EAEA,MAAM,YAAsC,CAK1C,OAAO,gBAAgB,KAAM,CAAE,cAAe,iBAAkB,CAAC,CACnE,EAEA,gBAAiB,MAEjB,QAAS,CAGP,MAAQ,eAAgB,IAAI,OAAY,CACtC,QAAS,aAAa,CAAE,KAAM,KAAK,IAAc,CAAC,CACpD,CAAC,CACH,EAEA,MAAM,OAAQ,CAGR,KAAK,gBAAgB,MAAM,KAAK,MAAM,CAC5C,CACF,CACF,CCrZA,SAAgB,UACd,GAAG,OACuB,CAC1B,IAAM,OAAS,OAAO,IAAK,GAAM,IAAI,EAAE,QAAQ,KAAM,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,EACvE,OAAO,IAAI,cAAyB,QAAQ,OAAO,EAAE,CACvD,CAGA,SAAgB,SAAiC,CAC/C,OAAO,IAAI,cAAsB,SAAS,CAC5C,CAGA,SAAgB,WAAmC,CACjD,OAAO,IAAI,cAAsB,WAAW,CAC9C,CAMA,SAAgB,SAAS,IAAmC,CAC1D,OAAO,IAAI,cAAoB,MAAQ,IAAA,GAAY,WAAa,YAAY,IAAI,EAAE,CACpF,CAGA,MAAM,cAAwC,CAC5C,QAAS,UACT,SAAU,WACV,UAAW,YACX,QAAS,MACT,IAAK,MACL,OAAQ,QACV,EAMA,SAAgB,SAEd,OAAc,CACd,IAAM,MAAS,OAAkD,MAC3D,KAAO,cAAc,MAAM,MACjC,GAAI,CAAC,KACH,MAAU,MAAM,eAAe,MAAM,KAAK,yBAAyB,EAGrE,MADA,OAAM,KAAO,GAAG,KAAK,WACd,MACT"}
1
+ {"version":3,"file":"mysql.mjs","names":[],"sources":["../src/adapters/mysql/dialect.ts","../src/adapters/mysql/adapter.ts","../src/dsl/columns/mysql.ts"],"sourcesContent":["// mysqlDialect — thin factory over Kysely's MysqlDialect so adopters\n// never have to reach for `import { MysqlDialect } from 'kysely'`.\n// Mirrors the `@forinda/kickjs-db/pg` template; the kysely subpackage\n// is a pinned internal dep of the framework.\n\nimport { MysqlDialect, type Dialect as KyselyDialect } from 'kysely'\nimport { KICK_DIALECT_DATES, markDialect, type DialectDateOptions } from '../../dialect-marker'\n\nimport type { MysqlPoolLike } from './adapter'\n\nexport interface MysqlDialectOptions {\n /**\n * mysql2-compatible pool — `createPool(...)` from `mysql2/promise`, the\n * same pool `mysqlAdapter` takes. A callback-API pool works too.\n */\n pool: MysqlPoolLike\n}\n\n/**\n * Construct the dialect that `createDbClient({ dialect })` consumes.\n *\n * **MySQL 8.0+ required.** Kickjs-db's relational query layer\n * compiles to `JSON_ARRAYAGG`, which shipped in 8.0. Adapter-side\n * version assertion lands at first connection from `mysqlAdapter()`;\n * see that factory's docs.\n *\n * @example\n * ```ts\n * import { createDbClient } from '@forinda/kickjs-db'\n * import { mysqlAdapter, mysqlDialect } from '@forinda/kickjs-db/mysql'\n * import { createPool } from 'mysql2/promise'\n *\n * const pool = createPool({\n * host: '127.0.0.1', user: 'root', password: '...', database: 'app',\n * })\n *\n * export const db = createDbClient({\n * schema,\n * dialect: mysqlDialect({ pool }),\n * })\n *\n * export const migrationAdapter = mysqlAdapter({ pool })\n * ```\n */\nexport function mysqlDialect(opts: MysqlDialectOptions): KyselyDialect {\n // MysqlDialect's `pool` parameter is typed as `mysql2.Pool` in\n // newer Kysely versions; casting through `unknown` keeps adopters\n // using compatible drivers (e.g. mysql-mariadb forks) working\n // without pulling mysql2's typings into our public surface.\n // Kysely's MysqlDialect drives the callback API (`getConnection(cb)`). A\n // `mysql2/promise` pool ignores the callback, so every query hung; its\n // callback-API core is `pool.pool` — hand Kysely that.\n const raw = opts.pool as unknown as { pool?: { getConnection?: unknown } }\n const callbackPool = typeof raw.pool?.getConnection === 'function' ? raw.pool : opts.pool\n const dialect = markDialect(new MysqlDialect({ pool: callbackPool as unknown as never }), 'mysql')\n // Rows nested by `db.query` carry dates as strings; read them the way\n // mysql2 reads top-level ones — in the pool's time zone, and not at all\n // for the types `dateStrings` keeps as strings.\n type Cfg = { timezone?: string; dateStrings?: boolean | string[] }\n const config = (callbackPool as { config?: { connectionConfig?: Cfg } }).config?.connectionConfig\n const dates: DialectDateOptions = {\n timezone: config?.timezone ?? 'local',\n dateStrings: config?.dateStrings ?? false,\n }\n Object.defineProperty(dialect, KICK_DIALECT_DATES, { value: dates, enumerable: false })\n return dialect\n}\n","import { Kysely } from 'kysely'\nimport { splitSqlStatements } from '../../migrate/split-statements'\nimport { mysqlDialect } from './dialect'\nimport {\n KickDbError,\n lockTableDdl,\n lockTableName,\n pushTableName,\n quoteTable,\n KICK_MIGRATIONS_TABLE,\n migrationsTableDdl,\n type Dialect,\n type MigrationAdapter,\n type MigrationBookkeeping,\n type MigrationRow,\n type SchemaSnapshot,\n} from '../../index'\nimport { introspectMysql } from '../../migrate/introspect-mysql'\n\n/**\n * mysql2-shaped pool that `mysqlAdapter` consumes. Mirrors the\n * structural surface of `mysql2/promise`'s Pool. The adapter only\n * uses `query(...)` and `getConnection(...)` so any mysql2-compatible\n * driver works.\n *\n * Return type is `Promise<[R, unknown]>` (not `[R[], unknown]`) so\n * mysql2's `Pool.query()` is structurally assignable: SELECT\n * statements return `RowDataPacket[]` (so callers pass `R =\n * MyRow[]`), INSERT / UPDATE / DELETE return `ResultSetHeader` (so\n * callers pass `R = ResultSetHeader`). Each adapter call site picks\n * the row shape it expects via the type parameter.\n */\nexport interface MysqlConnectionLike {\n // `any[]`, not `readonly unknown[]`: mysql2 declares its values parameter\n // mutable, and a readonly one here made a real mysql2 Pool unassignable.\n // oxlint-disable-next-line no-explicit-any\n query<R = unknown>(sql: string, params?: any[]): Promise<[R, unknown]>\n release(): void\n}\n\nexport interface MysqlPoolLike {\n // oxlint-disable-next-line no-explicit-any\n query<R = unknown>(sql: string, params?: any[]): Promise<[R, unknown]>\n getConnection(): Promise<MysqlConnectionLike>\n end?(): Promise<void>\n}\n\nexport interface MysqlAdapterOptions {\n /**\n * The table migrations are recorded in. Default `kick_migrations`; its lock\n * table is the same name plus `_lock`.\n */\n migrationsTable?: string\n /**\n * mysql2-compatible Pool. Caller-owned — `close()` on the adapter\n * does NOT end the pool because adopters typically share a single\n * pool across the migration adapter and the KickDbClient.\n */\n pool: MysqlPoolLike\n /**\n * End the pool when the adapter closes. Set it when the adapter owns its\n * pool — a `kick.config.ts` `db.adapter()` factory that opens one for the\n * CLI — or the `kick db` command never exits. Default `false`: an app\n * usually shares one pool with its client.\n */\n endPoolOnClose?: boolean\n}\n\n/**\n * Minimum supported MySQL major + MariaDB version. `JSON_ARRAYAGG`\n * shipped in MySQL 8.0 and MariaDB 10.5 — earlier versions can't\n * run kickjs-db's relational query layer.\n */\nconst MIN_MYSQL_MAJOR = 8\nconst MIN_MARIADB_MAJOR = 10\nconst MIN_MARIADB_MINOR = 5\n\n/**\n * Parsed shape returned by `parseMysqlVersion`. `flavor` lets\n * adopters distinguish MySQL from MariaDB without re-grepping the\n * raw string.\n */\nexport interface ParsedMysqlVersion {\n flavor: 'mysql' | 'mariadb'\n major: number\n minor: number\n}\n\n/**\n * Parse a MySQL `SELECT VERSION()` string. Handles:\n *\n * - MySQL: `8.0.34`, `8.4.0`, `5.7.42-log`\n * - MariaDB plain: `10.6.11-MariaDB`, `10.5.21-MariaDB-log`,\n * `10.4.32-MariaDB`\n * - MariaDB w/ compat prefix: `5.5.5-10.6.11-MariaDB-1:10.6.11+maria~ubu2004`\n * (the leading `5.5.5-` is a wire-protocol thing for older MySQL\n * clients; the real server version sits immediately before\n * `-MariaDB`)\n *\n * Returns `null` on unparseable input.\n */\nexport function parseMysqlVersion(version: string): ParsedMysqlVersion | null {\n const trimmed = version.trim()\n const isMariaDb = /MariaDB/i.test(trimmed)\n\n if (isMariaDb) {\n // Pull the `major.minor` that sits immediately before\n // `-MariaDB`. This skips the `5.5.5-` compat prefix when\n // present and grabs the real server version regardless of\n // whether one's there.\n const m = /(\\d+)\\.(\\d+)(?:\\.\\d+)?-MariaDB/i.exec(trimmed)\n if (m) {\n const major = Number(m[1])\n const minor = Number(m[2])\n if (Number.isFinite(major) && Number.isFinite(minor)) {\n return { flavor: 'mariadb', major, minor }\n }\n }\n // Fallback for vendor strings we haven't seen — try the\n // leading x.y. Better to surface the wrong floor than to\n // refuse an otherwise valid MariaDB outright.\n const fallback = /^(\\d+)\\.(\\d+)/.exec(trimmed)\n if (!fallback) return null\n const major = Number(fallback[1])\n const minor = Number(fallback[2])\n if (!Number.isFinite(major) || !Number.isFinite(minor)) return null\n return { flavor: 'mariadb', major, minor }\n }\n\n // MySQL: leading x.y from the start of the string.\n const m = /^(\\d+)\\.(\\d+)/.exec(trimmed)\n if (!m) return null\n const major = Number(m[1])\n const minor = Number(m[2])\n if (!Number.isFinite(major) || !Number.isFinite(minor)) return null\n return { flavor: 'mysql', major, minor }\n}\n\n/**\n * Back-compat shim — pre-existing API surface that returned the\n * major version only. Kept exported so adopters depending on it\n * keep working; new code should use `parseMysqlVersion`.\n *\n * @deprecated Use `parseMysqlVersion` for full version + flavor info.\n */\nexport function parseMysqlMajorVersion(version: string): number | null {\n const parsed = parseMysqlVersion(version)\n return parsed?.major ?? null\n}\n\n/**\n * Returns the failure reason if the parsed version doesn't satisfy\n * kickjs-db's floor, or `null` if it does. Pure — no I/O.\n */\nfunction checkVersionSupport(parsed: ParsedMysqlVersion | null, raw: string): string | null {\n if (parsed == null) {\n return `unparseable version string: ${raw || '<empty>'}`\n }\n if (parsed.flavor === 'mariadb') {\n if (parsed.major > MIN_MARIADB_MAJOR) return null\n if (parsed.major < MIN_MARIADB_MAJOR) {\n return `MariaDB ${MIN_MARIADB_MAJOR}.${MIN_MARIADB_MINOR}+ required (detected: ${raw})`\n }\n if (parsed.minor < MIN_MARIADB_MINOR) {\n return `MariaDB ${MIN_MARIADB_MAJOR}.${MIN_MARIADB_MINOR}+ required (detected: ${raw})`\n }\n return null\n }\n // MySQL flavor.\n if (parsed.major < MIN_MYSQL_MAJOR) {\n return `MySQL ${MIN_MYSQL_MAJOR}.0+ required (detected: ${raw})`\n }\n return null\n}\n\n/** {@link splitSqlStatements} for MySQL. */\nexport function splitMysqlStatements(sql: string): string[] {\n return splitSqlStatements(sql, 'mysql')\n}\n\n/**\n * MigrationAdapter implementation backed by mysql2.\n *\n * Asserts MySQL 8.0+ (or MariaDB 10.5+) on first connection (via\n * the first `ensureMigrationTables` call, lazily — no I/O at\n * construction time). Earlier versions throw `KickDbError` with\n * code `KICK_DB_RELATIONAL_NOT_SUPPORTED` carrying the detected\n * version so adopters get a clear error before any query reaches\n * the relational compiler.\n *\n * Multi-statement support: every `query()` call splits the SQL\n * blob at top-level semicolons and runs each statement\n * sequentially. Works against mysql2's default settings; adopters\n * who set `multipleStatements: true` on the pool pay no extra\n * cost (the split is cheap on small DDL blobs).\n *\n * Lock semantics: single-row UPDATE WHERE locked_at IS NULL on\n * `kick_migrations_lock`. Only the row created by\n * `ensureMigrationTables()` exists, so the UPDATE either flips\n * `locked_at` and returns `affectedRows=1` (we won) or matches\n * zero rows (someone else holds it).\n *\n * Introspection: not implemented in v1 — throws `KickDbError` with\n * code `KICK_DB_INTROSPECT_NOT_SUPPORTED`. Drift detection lands\n * in a follow-up that walks `information_schema`.\n */\nexport function mysqlAdapter(opts: MysqlAdapterOptions): MigrationAdapter {\n if (opts.endPoolOnClose && typeof opts.pool.end !== 'function') {\n throw new KickDbError(\n 'KICK_DB_POOL_NOT_CLOSABLE',\n 'mysqlAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close',\n )\n }\n const dialect: Dialect = 'mysql'\n const { pool } = opts\n let versionVerified = false\n\n async function assertVersion() {\n if (versionVerified) return\n const [rows] = await pool.query<{ version: string }[]>(`SELECT VERSION() AS \\`version\\``)\n const versionString = rows[0]?.version ?? ''\n const parsed = parseMysqlVersion(versionString)\n const failure = checkVersionSupport(parsed, versionString)\n if (failure) {\n throw new KickDbError(\n 'KICK_DB_RELATIONAL_NOT_SUPPORTED',\n `${failure}. JSON_ARRAYAGG (required by the relational query layer) shipped in ` +\n `MySQL 8.0 and MariaDB 10.5. Use layer-1/layer-2 queries (selectFrom / selectAll) ` +\n `on older versions.`,\n )\n }\n versionVerified = true\n }\n\n /**\n * Run a (possibly multi-statement) SQL blob via the pool,\n * splitting at top-level `;` so default mysql2 settings work.\n */\n async function runStatements(sql: string): Promise<void> {\n for (const stmt of splitMysqlStatements(sql)) {\n await pool.query(stmt)\n }\n }\n\n /**\n * Same as `runStatements` but on a held connection (used inside\n * `applySqlInTx` so all statements share the BEGIN / COMMIT\n * boundary).\n */\n async function runStatementsOnConn(conn: MysqlConnectionLike, sql: string): Promise<void> {\n for (const stmt of splitMysqlStatements(sql)) {\n await conn.query(stmt)\n }\n }\n\n const table = opts.migrationsTable ?? KICK_MIGRATIONS_TABLE\n const T = quoteTable(dialect, table)\n const L = quoteTable(dialect, lockTableName(table))\n // Introspection must not report the bookkeeping tables as schema.\n // A dot is part of the name here, not a schema.\n const bookkeepingTables = [table, lockTableName(table), pushTableName(table)]\n let migrationDb: Kysely<any> | undefined\n return {\n dialect,\n\n async ensureMigrationTables() {\n await assertVersion()\n await runStatements(migrationsTableDdl(dialect, table))\n await runStatements(lockTableDdl(dialect, table))\n },\n\n async listApplied(): Promise<MigrationRow[]> {\n const [rows] = await pool.query<\n Array<{\n id: string\n name: string\n hash: string\n batch: number\n applied_at: string | Date\n direction: 'up' | 'down'\n }>\n >(\n `SELECT id, name, hash, batch, applied_at, direction\n FROM ${T}\n ORDER BY applied_at ASC, id ASC`,\n )\n return rows.map((row) => ({\n id: row.id,\n name: row.name,\n hash: row.hash,\n batch: Number(row.batch),\n appliedAt:\n row.applied_at instanceof Date ? row.applied_at.toISOString() : String(row.applied_at),\n direction: row.direction,\n }))\n },\n\n async recordApplied(row) {\n await pool.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES (?, ?, ?, ?, ?)`,\n [row.id, row.name, row.hash, row.batch, row.direction],\n )\n },\n\n async removeApplied(id: string) {\n await pool.query(`DELETE FROM ${T} WHERE id = ?`, [id])\n },\n\n async acquireLock(owner: string, staleAfterSeconds?: number): Promise<boolean> {\n const [result] = await pool.query<{ affectedRows: number }>(\n staleAfterSeconds === undefined\n ? `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = ?\n WHERE id = 1 AND locked_at IS NULL`\n : `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = ?\n WHERE id = 1 AND (locked_at IS NULL OR locked_at < CURRENT_TIMESTAMP - INTERVAL ? SECOND)`,\n staleAfterSeconds === undefined ? [owner] : [owner, staleAfterSeconds],\n )\n return result.affectedRows === 1\n },\n\n async refreshLock(owner: string) {\n // mysql2 reports matched rows (FOUND_ROWS), so a refresh in the same second still counts.\n const [result] = await pool.query<{ affectedRows: number }>(\n `UPDATE ${L} SET locked_at = CURRENT_TIMESTAMP WHERE id = 1 AND locked_by = ?`,\n [owner],\n )\n return result.affectedRows === 1\n },\n\n async releaseLock(owner?: string) {\n await pool.query(\n `UPDATE ${L}\n SET locked_at = NULL, locked_by = NULL\n WHERE id = 1 AND (? IS NULL OR locked_by = ?)`,\n [owner ?? null, owner ?? null],\n )\n },\n\n async lockHolder() {\n const [rows] = await pool.query<{ locked_by: string | null }[]>(\n `SELECT locked_by FROM ${L} WHERE id = 1 AND locked_at IS NOT NULL`,\n )\n return rows[0]?.locked_by ?? null\n },\n\n async applySqlInTx(sql: string) {\n await this.applyMigrationInTx!(sql, null)\n },\n\n // MySQL commits DDL as it runs (an implicit COMMIT that ends this\n // transaction), so for a migration with DDL this is not atomic: the\n // schema change is committed before the bookkeeping row is written, and a\n // crash in between leaves it applied but unrecorded. Only a migration of\n // plain DML statements commits with its row.\n async applyMigrationInTx(sql: string, bookkeeping: MigrationBookkeeping | null) {\n const conn = await pool.getConnection()\n try {\n await conn.query('START TRANSACTION')\n await runStatementsOnConn(conn, sql)\n if (bookkeeping && 'record' in bookkeeping) {\n const r = bookkeeping.record\n await conn.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES (?, ?, ?, ?, ?)`,\n [r.id, r.name, r.hash, r.batch, r.direction],\n )\n } else if (bookkeeping) {\n await conn.query(`DELETE FROM ${T} WHERE id = ?`, [bookkeeping.remove])\n }\n await conn.query('COMMIT')\n } catch (err) {\n await conn.query('ROLLBACK').catch(() => {\n // Swallow rollback errors; we're already throwing the original.\n })\n throw err\n } finally {\n conn.release()\n }\n },\n\n async applySqlNoTx(sql: string) {\n await runStatements(sql)\n },\n\n async introspect(): Promise<SchemaSnapshot> {\n // Reverse-engineer the live schema via information_schema. Types come\n // back as the declared COLUMN_TYPE (a code-first `uuid()` reads as\n // `char(36)`), so this powers `kick db introspect`; byte-exact drift\n // against a code-first snapshot needs a dialect-normalised compare.\n return introspectMysql(pool, { excludeTables: bookkeepingTables })\n },\n\n migrationsTable: table,\n\n kysely() {\n // Built once, on the same connection. Never destroyed here: the pool or\n // handle belongs to the caller (or to close()).\n return (migrationDb ??= new Kysely<any>({\n dialect: mysqlDialect({ pool: opts.pool as never }),\n }))\n },\n\n async close() {\n // The caller owns the pool unless it said otherwise — adopters\n // typically share it with the KickDbClient.\n if (opts.endPoolOnClose) await pool.end?.()\n },\n }\n}\n","import { ColumnBuilder } from './types'\n\n/**\n * A MySQL `ENUM`: `status: mysqlEnum('active', 'archived')`, typed as the\n * union of its values. The values keep their case.\n */\nexport function mysqlEnum<const V extends readonly [string, ...string[]]>(\n ...values: V\n): ColumnBuilder<V[number]> {\n const quoted = values.map((v) => `'${v.replace(/'/g, \"''\")}'`).join(',')\n return new ColumnBuilder<V[number]>(`enum(${quoted})`)\n}\n\n/** A 1-byte integer (`TINYINT`, -128…127; 0…255 with {@link unsigned}). */\nexport function tinyint(): ColumnBuilder<number> {\n return new ColumnBuilder<number>('tinyint')\n}\n\n/** A 3-byte integer (`MEDIUMINT`). */\nexport function mediumint(): ColumnBuilder<number> {\n return new ColumnBuilder<number>('mediumint')\n}\n\n/**\n * `DATETIME`, with fractional seconds when given: `datetime(3)`. Unlike\n * `TIMESTAMP` it isn't converted to UTC, and it holds years 1000–9999.\n */\nexport function datetime(fsp?: number): ColumnBuilder<Date> {\n return new ColumnBuilder<Date>(fsp === undefined ? 'datetime' : `datetime(${fsp})`)\n}\n\n/** MySQL's spelling of each integer column type kick/db has. */\nconst INTEGER_TYPES: Record<string, string> = {\n tinyint: 'tinyint',\n smallint: 'smallint',\n mediumint: 'mediumint',\n integer: 'int',\n int: 'int',\n bigint: 'bigint',\n}\n\n/**\n * Make an integer column `UNSIGNED`: `unsigned(integer())`,\n * `unsigned(bigint({ mode: 'bigint' }))`. Its type and chain stay as they were.\n */\nexport function unsigned<\n C extends ColumnBuilder<number> | ColumnBuilder<bigint> | ColumnBuilder<string>,\n>(column: C): C {\n const state = (column as unknown as { state: { type: string } }).state\n const base = INTEGER_TYPES[state.type]\n if (!base) {\n throw new Error(`unsigned(): ${state.type} isn't an integer column`)\n }\n state.type = `${base} unsigned`\n return column\n}\n"],"mappings":"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"}
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @forinda/kickjs-db v8.12.4
2
+ * @forinda/kickjs-db v8.13.0
3
3
  *
4
4
  * Copyright (c) Felix Orinda
5
5
  *
@@ -8,5 +8,5 @@
8
8
  *
9
9
  * @license MIT
10
10
  */
11
- import{r as ColumnBuilder,t as CustomColumnBuilder}from"./custom-type-CNmg8h4k.mjs";var PgEnumColumnBuilder=class extends ColumnBuilder{enumName;values;constructor(enumName,values){super(enumName),this.enumName=enumName,this.values=values}};function pgEnum(name,...values){return Object.assign(()=>new PgEnumColumnBuilder(name,values),{enumName:name,values})}function tsvector(){return new ColumnBuilder(`tsvector`)}var PgCodecColumnBuilder=class extends CustomColumnBuilder{};const vectorToDriver=v=>`[${v.join(`,`)}]`,vectorFromDriver=raw=>typeof raw==`string`?JSON.parse(raw):raw;function vectorColumn(base,dim){return new PgCodecColumnBuilder({dataType:()=>dim===void 0?base:`${base}(${dim})`,toDriver:vectorToDriver,fromDriver:vectorFromDriver})}function vector(dim){return vectorColumn(`vector`,dim)}function halfvec(dim){return vectorColumn(`halfvec`,dim)}const pointToDriver=p=>`(${p.x},${p.y})`,pointFromDriver=raw=>{if(typeof raw!=`string`)return raw;let[x,y]=raw.replace(/[()\s]/g,``).split(`,`).map(Number);return{x,y}};function point(){return new PgCodecColumnBuilder({dataType:()=>`point`,toDriver:pointToDriver,fromDriver:pointFromDriver})}function geometry(type,srid){let args=[type,srid].filter(a=>a!==void 0);return new ColumnBuilder(args.length?`geometry(${args.join(`, `)})`:`geometry`)}function macaddr(){return new ColumnBuilder(`macaddr`)}function macaddr8(){return new ColumnBuilder(`macaddr8`)}function citext(){return new ColumnBuilder(`citext`)}function money(){return new ColumnBuilder(`money`)}function inet(){return new ColumnBuilder(`inet`)}function cidr(){return new ColumnBuilder(`cidr`)}function xml(){return new ColumnBuilder(`xml`)}export{geometry as a,macaddr as c,pgEnum as d,point as f,xml as h,citext as i,macaddr8 as l,vector as m,PgEnumColumnBuilder as n,halfvec as o,tsvector as p,cidr as r,inet as s,PgCodecColumnBuilder as t,money as u};
12
- //# sourceMappingURL=pg-lghOiA3k.mjs.map
11
+ import{r as ColumnBuilder,t as CustomColumnBuilder}from"./custom-type-CyQYFrA5.mjs";var PgEnumColumnBuilder=class extends ColumnBuilder{enumName;values;constructor(enumName,values){super(enumName),this.enumName=enumName,this.values=values}};function pgEnum(name,...values){return Object.assign(()=>new PgEnumColumnBuilder(name,values),{enumName:name,values})}function tsvector(){return new ColumnBuilder(`tsvector`)}var PgCodecColumnBuilder=class extends CustomColumnBuilder{};const vectorToDriver=v=>`[${v.join(`,`)}]`,vectorFromDriver=raw=>typeof raw==`string`?JSON.parse(raw):raw;function vectorColumn(base,dim){return new PgCodecColumnBuilder({dataType:()=>dim===void 0?base:`${base}(${dim})`,toDriver:vectorToDriver,fromDriver:vectorFromDriver})}function vector(dim){return vectorColumn(`vector`,dim)}function halfvec(dim){return vectorColumn(`halfvec`,dim)}const pointToDriver=p=>`(${p.x},${p.y})`,pointFromDriver=raw=>{if(typeof raw!=`string`)return raw;let[x,y]=raw.replace(/[()\s]/g,``).split(`,`).map(Number);return{x,y}};function point(){return new PgCodecColumnBuilder({dataType:()=>`point`,toDriver:pointToDriver,fromDriver:pointFromDriver})}function geometry(type,srid){let args=[type,srid].filter(a=>a!==void 0);return new ColumnBuilder(args.length?`geometry(${args.join(`, `)})`:`geometry`)}function macaddr(){return new ColumnBuilder(`macaddr`)}function macaddr8(){return new ColumnBuilder(`macaddr8`)}function citext(){return new ColumnBuilder(`citext`)}function money(){return new ColumnBuilder(`money`)}function inet(){return new ColumnBuilder(`inet`)}function cidr(){return new ColumnBuilder(`cidr`)}function xml(){return new ColumnBuilder(`xml`)}export{geometry as a,macaddr as c,pgEnum as d,point as f,xml as h,citext as i,macaddr8 as l,vector as m,PgEnumColumnBuilder as n,halfvec as o,tsvector as p,cidr as r,inet as s,PgCodecColumnBuilder as t,money as u};
12
+ //# sourceMappingURL=pg-0Zp1q4gP.mjs.map
@@ -1 +1 @@
1
- {"version":3,"file":"pg-lghOiA3k.mjs","names":[],"sources":["../src/dsl/columns/pg.ts"],"sourcesContent":["import { CustomColumnBuilder } from '../../custom-type'\nimport { ColumnBuilder } from './types'\n\n// PG-only column types. Phantom T per builder so SchemaToTypes<S> can narrow\n// each column to a useful TS shape — strings for the text-y types, number[]\n// for vector embeddings, etc.\n\n/**\n * Declare a PostgreSQL ENUM type.\n *\n * @example\n * ```ts\n * export const taskStatus = pgEnum('task_status', 'todo', 'in_progress', 'done')\n *\n * export const tasks = table('tasks', {\n * id: uuid().primaryKey().defaultRandom(),\n * status: taskStatus().notNull().default('todo'),\n * })\n * ```\n *\n * The factory returns a column builder whose phantom type narrows to\n * the union of the declared values — `db.selectFrom('tasks').select('status')`\n * types `status: 'todo' | 'in_progress' | 'done'`.\n *\n * Schema-level state (the enum name + values) is attached to every\n * column the factory produces so introspection / drift / emit can pick\n * it up: `kick db generate` emits the `CREATE TYPE <name> AS ENUM (...)`\n * before the first table that uses it, and later value changes as\n * migrations.\n */\nexport interface PgEnumBuilder<TName extends string, TValues extends readonly string[]> {\n (): PgEnumColumnBuilder<TName, TValues>\n /** The SQL identifier — used by emit + drift detection. */\n readonly enumName: TName\n /** Allowed literal values, in declaration order. */\n readonly values: TValues\n}\n\n/** The column a {@link pgEnum} factory makes, typed as the union of its values. */\nexport class PgEnumColumnBuilder<\n TName extends string,\n TValues extends readonly string[],\n> extends ColumnBuilder<TValues[number]> {\n /** The enum's SQL identifier — preserved for emit + drift detection. */\n readonly enumName: TName\n /** Allowed values — readonly to prevent mutation across columns. */\n readonly values: TValues\n\n constructor(enumName: TName, values: TValues) {\n // The SQL data type IS the enum identifier — `status task_status`,\n // not `status text` — so PG enforces the membership constraint.\n super(enumName)\n this.enumName = enumName\n this.values = values\n }\n}\n\n// Variadic rest forces TS to infer EACH value as its literal type, so\n// `pgEnum('s', 'todo', 'done')` resolves to\n// `PgEnumBuilder<'s', ['todo', 'done']>`. Without rest, an array\n// literal stored in a variable would widen to `string[]` and the\n// column phantom would collapse to plain `string`, defeating the\n// entire point of the helper. Adopters with a pre-existing array\n// can still spread it: `pgEnum('s', ...VALUES as const)`.\n/**\n * Declare a Postgres ENUM type; call the result to make a column of it.\n *\n * @example\n * export const taskStatus = pgEnum('task_status', 'todo', 'in_progress', 'done')\n * status: taskStatus().notNull().default('todo') // 'todo' | 'in_progress' | 'done'\n */\nexport function pgEnum<TName extends string, const TValues extends readonly [string, ...string[]]>(\n name: TName,\n ...values: TValues\n): PgEnumBuilder<TName, TValues> {\n const factory = (): PgEnumColumnBuilder<TName, TValues> =>\n new PgEnumColumnBuilder<TName, TValues>(name, values)\n // Attach metadata to the factory itself so introspection that walks\n // `Object.values(schema)` can discover enum declarations even when\n // they're declared standalone (without a column reference).\n return Object.assign(factory, { enumName: name, values }) as PgEnumBuilder<TName, TValues>\n}\n\n/** A full-text search vector (`tsvector`), typed `string`. Index it with GIN. */\nexport function tsvector(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('tsvector')\n}\n\n/**\n * A built-in column whose values the driver doesn't convert, with the codecs\n * that do. Validators still know its type (a custom type reads as \"any\").\n * Codecs are shared module-level functions: they're keyed by column name, and\n * one instance per type keeps same-named columns in different tables quiet.\n */\nexport class PgCodecColumnBuilder<T> extends CustomColumnBuilder<T> {}\n\n/** pgvector's text form is `[1,2,3]`: valid JSON both ways. */\nconst vectorToDriver = (v: number[]) => `[${v.join(',')}]`\nconst vectorFromDriver = (raw: unknown): number[] =>\n typeof raw === 'string' ? (JSON.parse(raw) as number[]) : (raw as number[])\n\nfunction vectorColumn(base: string, dim?: number): PgCodecColumnBuilder<number[]> {\n return new PgCodecColumnBuilder<number[]>({\n dataType: () => (dim === undefined ? base : `${base}(${dim})`),\n toDriver: vectorToDriver,\n fromDriver: vectorFromDriver,\n })\n}\n\n/** A pgvector embedding (`vector(n)`), as `number[]`. Needs the `vector` extension. */\nexport function vector(dim?: number): PgCodecColumnBuilder<number[]> {\n return vectorColumn('vector', dim)\n}\n\n/** A half-precision pgvector embedding (`halfvec(n)`, pgvector 0.7+), as `number[]`. */\nexport function halfvec(dim?: number): PgCodecColumnBuilder<number[]> {\n return vectorColumn('halfvec', dim)\n}\n\n/** A point on a plane. */\nexport interface PgPoint {\n x: number\n y: number\n}\n\nconst pointToDriver = (p: PgPoint) => `(${p.x},${p.y})`\nconst pointFromDriver = (raw: unknown): PgPoint => {\n if (typeof raw !== 'string') return raw as PgPoint // `pg` already parses it\n const [x, y] = raw\n .replace(/[()\\s]/g, '')\n .split(',')\n .map(Number)\n return { x: x!, y: y! }\n}\n\n/** Postgres' geometric `point`, as `{ x, y }`. */\nexport function point(): PgCodecColumnBuilder<PgPoint> {\n return new PgCodecColumnBuilder<PgPoint>({\n dataType: () => 'point',\n toDriver: pointToDriver,\n fromDriver: pointFromDriver,\n })\n}\n\n/**\n * A PostGIS geometry: `geometry('Point', 4326)` → `geometry(Point, 4326)`.\n * The value is what PostGIS returns (hex EWKB) and takes text in (WKT or\n * EWKT, `'SRID=4326;POINT(36.8 -1.28)'`); convert with `ST_AsGeoJSON` /\n * `ST_GeomFromGeoJSON` in SQL. Needs the `postgis` extension.\n */\nexport function geometry(type?: string, srid?: number): ColumnBuilder<string> {\n const args = [type, srid].filter((a) => a !== undefined)\n return new ColumnBuilder<string>(args.length ? `geometry(${args.join(', ')})` : 'geometry')\n}\n\n/** A MAC address (`08:00:2b:01:02:03`). */\nexport function macaddr(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('macaddr')\n}\n\n/** An EUI-64 MAC address. */\nexport function macaddr8(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('macaddr8')\n}\n\n/** Case-insensitive text (`citext`), typed `string`. Needs the `citext` extension. */\nexport function citext(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('citext')\n}\n\n/** Currency (`money`), typed `string` as the server formats it (`'$1,234.50'`). Prefer `decimal(p, s)`. */\nexport function money(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('money')\n}\n\n/** An IPv4 or IPv6 host address, optionally with a netmask (`inet`), typed `string`. */\nexport function inet(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('inet')\n}\n\n/** An IPv4 or IPv6 network (`cidr`, e.g. `'10.0.0.0/8'`), typed `string`. */\nexport function cidr(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('cidr')\n}\n\n/** An XML document (`xml`), typed `string`. */\nexport function xml(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('xml')\n}\n"],"mappings":";;;;;;;;;;oFAuCA,IAAa,oBAAb,cAGU,aAA+B,CAEvC,SAEA,OAEA,YAAY,SAAiB,OAAiB,CAG5C,MAAM,QAAQ,EACd,KAAK,SAAW,SAChB,KAAK,OAAS,MAChB,CACF,EAgBA,SAAgB,OACd,KACA,GAAG,OAC4B,CAM/B,OAAO,OAAO,WAJZ,IAAI,oBAAoC,KAAM,MAAM,EAIxB,CAAE,SAAU,KAAM,MAAO,CAAC,CAC1D,CAGA,SAAgB,UAAkC,CAChD,OAAO,IAAI,cAAsB,UAAU,CAC7C,CAQA,IAAa,qBAAb,cAA6C,mBAAuB,CAAC,EAGrE,MAAM,eAAkB,GAAgB,IAAI,EAAE,KAAK,GAAG,EAAE,GAClD,iBAAoB,KACxB,OAAO,KAAQ,SAAY,KAAK,MAAM,GAAG,EAAkB,IAE7D,SAAS,aAAa,KAAc,IAA8C,CAChF,OAAO,IAAI,qBAA+B,CACxC,aAAiB,MAAQ,IAAA,GAAY,KAAO,GAAG,KAAK,GAAG,IAAI,GAC3D,SAAU,eACV,WAAY,gBACd,CAAC,CACH,CAGA,SAAgB,OAAO,IAA8C,CACnE,OAAO,aAAa,SAAU,GAAG,CACnC,CAGA,SAAgB,QAAQ,IAA8C,CACpE,OAAO,aAAa,UAAW,GAAG,CACpC,CAQA,MAAM,cAAiB,GAAe,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,GAC/C,gBAAmB,KAA0B,CACjD,GAAI,OAAO,KAAQ,SAAU,OAAO,IACpC,GAAM,CAAC,EAAG,GAAK,IACZ,QAAQ,UAAW,EAAE,CAAC,CACtB,MAAM,GAAG,CAAC,CACV,IAAI,MAAM,EACb,MAAO,CAAK,EAAO,CAAG,CACxB,EAGA,SAAgB,OAAuC,CACrD,OAAO,IAAI,qBAA8B,CACvC,aAAgB,QAChB,SAAU,cACV,WAAY,eACd,CAAC,CACH,CAQA,SAAgB,SAAS,KAAe,KAAsC,CAC5E,IAAM,KAAO,CAAC,KAAM,IAAI,CAAC,CAAC,OAAQ,GAAM,IAAM,IAAA,EAAS,EACvD,OAAO,IAAI,cAAsB,KAAK,OAAS,YAAY,KAAK,KAAK,IAAI,EAAE,GAAK,UAAU,CAC5F,CAGA,SAAgB,SAAiC,CAC/C,OAAO,IAAI,cAAsB,SAAS,CAC5C,CAGA,SAAgB,UAAkC,CAChD,OAAO,IAAI,cAAsB,UAAU,CAC7C,CAGA,SAAgB,QAAgC,CAC9C,OAAO,IAAI,cAAsB,QAAQ,CAC3C,CAGA,SAAgB,OAA+B,CAC7C,OAAO,IAAI,cAAsB,OAAO,CAC1C,CAGA,SAAgB,MAA8B,CAC5C,OAAO,IAAI,cAAsB,MAAM,CACzC,CAGA,SAAgB,MAA8B,CAC5C,OAAO,IAAI,cAAsB,MAAM,CACzC,CAGA,SAAgB,KAA6B,CAC3C,OAAO,IAAI,cAAsB,KAAK,CACxC"}
1
+ {"version":3,"file":"pg-0Zp1q4gP.mjs","names":[],"sources":["../src/dsl/columns/pg.ts"],"sourcesContent":["import { CustomColumnBuilder } from '../../custom-type'\nimport { ColumnBuilder } from './types'\n\n// PG-only column types. Phantom T per builder so SchemaToTypes<S> can narrow\n// each column to a useful TS shape — strings for the text-y types, number[]\n// for vector embeddings, etc.\n\n/**\n * Declare a PostgreSQL ENUM type.\n *\n * @example\n * ```ts\n * export const taskStatus = pgEnum('task_status', 'todo', 'in_progress', 'done')\n *\n * export const tasks = table('tasks', {\n * id: uuid().primaryKey().defaultRandom(),\n * status: taskStatus().notNull().default('todo'),\n * })\n * ```\n *\n * The factory returns a column builder whose phantom type narrows to\n * the union of the declared values — `db.selectFrom('tasks').select('status')`\n * types `status: 'todo' | 'in_progress' | 'done'`.\n *\n * Schema-level state (the enum name + values) is attached to every\n * column the factory produces so introspection / drift / emit can pick\n * it up: `kick db generate` emits the `CREATE TYPE <name> AS ENUM (...)`\n * before the first table that uses it, and later value changes as\n * migrations.\n */\nexport interface PgEnumBuilder<TName extends string, TValues extends readonly string[]> {\n (): PgEnumColumnBuilder<TName, TValues>\n /** The SQL identifier — used by emit + drift detection. */\n readonly enumName: TName\n /** Allowed literal values, in declaration order. */\n readonly values: TValues\n}\n\n/** The column a {@link pgEnum} factory makes, typed as the union of its values. */\nexport class PgEnumColumnBuilder<\n TName extends string,\n TValues extends readonly string[],\n> extends ColumnBuilder<TValues[number]> {\n /** The enum's SQL identifier — preserved for emit + drift detection. */\n readonly enumName: TName\n /** Allowed values — readonly to prevent mutation across columns. */\n readonly values: TValues\n\n constructor(enumName: TName, values: TValues) {\n // The SQL data type IS the enum identifier — `status task_status`,\n // not `status text` — so PG enforces the membership constraint.\n super(enumName)\n this.enumName = enumName\n this.values = values\n }\n}\n\n// Variadic rest forces TS to infer EACH value as its literal type, so\n// `pgEnum('s', 'todo', 'done')` resolves to\n// `PgEnumBuilder<'s', ['todo', 'done']>`. Without rest, an array\n// literal stored in a variable would widen to `string[]` and the\n// column phantom would collapse to plain `string`, defeating the\n// entire point of the helper. Adopters with a pre-existing array\n// can still spread it: `pgEnum('s', ...VALUES as const)`.\n/**\n * Declare a Postgres ENUM type; call the result to make a column of it.\n *\n * @example\n * export const taskStatus = pgEnum('task_status', 'todo', 'in_progress', 'done')\n * status: taskStatus().notNull().default('todo') // 'todo' | 'in_progress' | 'done'\n */\nexport function pgEnum<TName extends string, const TValues extends readonly [string, ...string[]]>(\n name: TName,\n ...values: TValues\n): PgEnumBuilder<TName, TValues> {\n const factory = (): PgEnumColumnBuilder<TName, TValues> =>\n new PgEnumColumnBuilder<TName, TValues>(name, values)\n // Attach metadata to the factory itself so introspection that walks\n // `Object.values(schema)` can discover enum declarations even when\n // they're declared standalone (without a column reference).\n return Object.assign(factory, { enumName: name, values }) as PgEnumBuilder<TName, TValues>\n}\n\n/** A full-text search vector (`tsvector`), typed `string`. Index it with GIN. */\nexport function tsvector(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('tsvector')\n}\n\n/**\n * A built-in column whose values the driver doesn't convert, with the codecs\n * that do. Validators still know its type (a custom type reads as \"any\").\n * Codecs are shared module-level functions: they're keyed by column name, and\n * one instance per type keeps same-named columns in different tables quiet.\n */\nexport class PgCodecColumnBuilder<T> extends CustomColumnBuilder<T> {}\n\n/** pgvector's text form is `[1,2,3]`: valid JSON both ways. */\nconst vectorToDriver = (v: number[]) => `[${v.join(',')}]`\nconst vectorFromDriver = (raw: unknown): number[] =>\n typeof raw === 'string' ? (JSON.parse(raw) as number[]) : (raw as number[])\n\nfunction vectorColumn(base: string, dim?: number): PgCodecColumnBuilder<number[]> {\n return new PgCodecColumnBuilder<number[]>({\n dataType: () => (dim === undefined ? base : `${base}(${dim})`),\n toDriver: vectorToDriver,\n fromDriver: vectorFromDriver,\n })\n}\n\n/** A pgvector embedding (`vector(n)`), as `number[]`. Needs the `vector` extension. */\nexport function vector(dim?: number): PgCodecColumnBuilder<number[]> {\n return vectorColumn('vector', dim)\n}\n\n/** A half-precision pgvector embedding (`halfvec(n)`, pgvector 0.7+), as `number[]`. */\nexport function halfvec(dim?: number): PgCodecColumnBuilder<number[]> {\n return vectorColumn('halfvec', dim)\n}\n\n/** A point on a plane. */\nexport interface PgPoint {\n x: number\n y: number\n}\n\nconst pointToDriver = (p: PgPoint) => `(${p.x},${p.y})`\nconst pointFromDriver = (raw: unknown): PgPoint => {\n if (typeof raw !== 'string') return raw as PgPoint // `pg` already parses it\n const [x, y] = raw\n .replace(/[()\\s]/g, '')\n .split(',')\n .map(Number)\n return { x: x!, y: y! }\n}\n\n/** Postgres' geometric `point`, as `{ x, y }`. */\nexport function point(): PgCodecColumnBuilder<PgPoint> {\n return new PgCodecColumnBuilder<PgPoint>({\n dataType: () => 'point',\n toDriver: pointToDriver,\n fromDriver: pointFromDriver,\n })\n}\n\n/**\n * A PostGIS geometry: `geometry('Point', 4326)` → `geometry(Point, 4326)`.\n * The value is what PostGIS returns (hex EWKB) and takes text in (WKT or\n * EWKT, `'SRID=4326;POINT(36.8 -1.28)'`); convert with `ST_AsGeoJSON` /\n * `ST_GeomFromGeoJSON` in SQL. Needs the `postgis` extension.\n */\nexport function geometry(type?: string, srid?: number): ColumnBuilder<string> {\n const args = [type, srid].filter((a) => a !== undefined)\n return new ColumnBuilder<string>(args.length ? `geometry(${args.join(', ')})` : 'geometry')\n}\n\n/** A MAC address (`08:00:2b:01:02:03`). */\nexport function macaddr(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('macaddr')\n}\n\n/** An EUI-64 MAC address. */\nexport function macaddr8(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('macaddr8')\n}\n\n/** Case-insensitive text (`citext`), typed `string`. Needs the `citext` extension. */\nexport function citext(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('citext')\n}\n\n/** Currency (`money`), typed `string` as the server formats it (`'$1,234.50'`). Prefer `decimal(p, s)`. */\nexport function money(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('money')\n}\n\n/** An IPv4 or IPv6 host address, optionally with a netmask (`inet`), typed `string`. */\nexport function inet(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('inet')\n}\n\n/** An IPv4 or IPv6 network (`cidr`, e.g. `'10.0.0.0/8'`), typed `string`. */\nexport function cidr(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('cidr')\n}\n\n/** An XML document (`xml`), typed `string`. */\nexport function xml(): ColumnBuilder<string> {\n return new ColumnBuilder<string>('xml')\n}\n"],"mappings":";;;;;;;;;;A,oFAuCA,IAAa,oBAAb,cAGU,aAA+B,CAE9B,SAEA,OAET,YAAY,SAAiB,OAAiB,CAG5C,MAAM,QAAQ,EACd,KAAK,SAAW,SAChB,KAAK,OAAS,MAChB,CACF,EAgBA,SAAgB,OACd,KACA,GAAG,OAC4B,CAM/B,OAAO,OAAO,WAJZ,IAAI,oBAAoC,KAAM,MAAM,EAIxB,CAAE,SAAU,KAAM,MAAO,CAAC,CAC1D,CAGA,SAAgB,UAAkC,CAChD,OAAO,IAAI,cAAsB,UAAU,CAC7C,CAQA,IAAa,qBAAb,cAA6C,mBAAuB,CAAC,EAGrE,MAAM,eAAkB,GAAgB,IAAI,EAAE,KAAK,GAAG,EAAE,GAClD,iBAAoB,KACxB,OAAO,KAAQ,SAAY,KAAK,MAAM,GAAG,EAAkB,IAE7D,SAAS,aAAa,KAAc,IAA8C,CAChF,OAAO,IAAI,qBAA+B,CACxC,aAAiB,MAAQ,IAAA,GAAY,KAAO,GAAG,KAAK,GAAG,IAAI,GAC3D,SAAU,eACV,WAAY,gBACd,CAAC,CACH,CAGA,SAAgB,OAAO,IAA8C,CACnE,OAAO,aAAa,SAAU,GAAG,CACnC,CAGA,SAAgB,QAAQ,IAA8C,CACpE,OAAO,aAAa,UAAW,GAAG,CACpC,CAQA,MAAM,cAAiB,GAAe,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,GAC/C,gBAAmB,KAA0B,CACjD,GAAI,OAAO,KAAQ,SAAU,OAAO,IACpC,GAAM,CAAC,EAAG,GAAK,IACZ,QAAQ,UAAW,EAAE,CAAC,CACtB,MAAM,GAAG,CAAC,CACV,IAAI,MAAM,EACb,MAAO,CAAK,EAAO,CAAG,CACxB,EAGA,SAAgB,OAAuC,CACrD,OAAO,IAAI,qBAA8B,CACvC,aAAgB,QAChB,SAAU,cACV,WAAY,eACd,CAAC,CACH,CAQA,SAAgB,SAAS,KAAe,KAAsC,CAC5E,IAAM,KAAO,CAAC,KAAM,IAAI,CAAC,CAAC,OAAQ,GAAM,IAAM,IAAA,EAAS,EACvD,OAAO,IAAI,cAAsB,KAAK,OAAS,YAAY,KAAK,KAAK,IAAI,EAAE,GAAK,UAAU,CAC5F,CAGA,SAAgB,SAAiC,CAC/C,OAAO,IAAI,cAAsB,SAAS,CAC5C,CAGA,SAAgB,UAAkC,CAChD,OAAO,IAAI,cAAsB,UAAU,CAC7C,CAGA,SAAgB,QAAgC,CAC9C,OAAO,IAAI,cAAsB,QAAQ,CAC3C,CAGA,SAAgB,OAA+B,CAC7C,OAAO,IAAI,cAAsB,OAAO,CAC1C,CAGA,SAAgB,MAA8B,CAC5C,OAAO,IAAI,cAAsB,MAAM,CACzC,CAGA,SAAgB,MAA8B,CAC5C,OAAO,IAAI,cAAsB,MAAM,CACzC,CAGA,SAAgB,KAA6B,CAC3C,OAAO,IAAI,cAAsB,KAAK,CACxC,C"}
package/dist/pg.d.mts CHANGED
@@ -1,10 +1,9 @@
1
1
 
2
- import { m as TypedColumnRefs, n as ColumnBuilder, t as CheckSelfRefs } from "./types-DB_xyeQT.mjs";
3
- import { Dt as ViewDecl, Et as MaterializedViewOptions, M as CustomColumnBuilder } from "./index-Nf43jLx4.mjs";
4
- import { _ as PolicyDecl, b as pgRole, n as TableDecl, r as TableOptions, v as RoleDecl, x as policy, y as isRole } from "./table-BGk08X3C.mjs";
5
- import { i as pgAdapter, n as PgClientLike, r as PgPoolLike, t as PgAdapterOptions } from "./adapter-cVrkWrul.mjs";
2
+ import { Dt as ViewDecl, Et as MaterializedViewOptions, M as CustomColumnBuilder } from "./index-AaU739CK.mjs";
3
+ import { m as TypedColumnRefs, n as ColumnBuilder, t as CheckSelfRefs } from "./types-D4x2u-EZ.mjs";
4
+ import { _ as PolicyDecl, b as pgRole, n as TableDecl, r as TableOptions, v as RoleDecl, x as policy, y as isRole } from "./table-B8eYtdq_.mjs";
5
+ import { i as pgAdapter, n as PgClientLike, r as PgPoolLike, t as PgAdapterOptions } from "./adapter-HRQJb4xQ.mjs";
6
6
  import { Dialect } from "kysely";
7
- //#region src/dsl/columns/pg.d.ts
8
7
  /**
9
8
  * Declare a PostgreSQL ENUM type.
10
9
  *
@@ -92,8 +91,6 @@ export declare function inet(): ColumnBuilder<string>;
92
91
  export declare function cidr(): ColumnBuilder<string>;
93
92
  /** An XML document (`xml`), typed `string`. */
94
93
  export declare function xml(): ColumnBuilder<string>;
95
- //#endregion
96
- //#region src/dsl/pg-schema.d.ts
97
94
  /**
98
95
  * PostgreSQL named-schema namespace.
99
96
  *
@@ -147,8 +144,6 @@ type EffectiveSchema<TName extends string> = TName extends 'public' ? undefined
147
144
  */
148
145
  export declare function pgSchema<TName extends string>(name: TName): PgSchema<EffectiveSchema<TName>>;
149
146
  export declare function isPgSchema(value: unknown): value is PgSchema<string>;
150
- //#endregion
151
- //#region src/adapters/pg/dialect.d.ts
152
147
  export interface PgDialectOptions {
153
148
  /**
154
149
  * pg-protocol-compatible pool. Both `pg.Pool` and
@@ -182,8 +177,6 @@ export interface PgDialectOptions {
182
177
  * ```
183
178
  */
184
179
  export declare function pgDialect(opts: PgDialectOptions): Dialect;
185
- //#endregion
186
- //#region src/dsl/pg-views.d.ts
187
180
  /**
188
181
  * A materialized view (Postgres): the `SELECT`'s result stored as a table,
189
182
  * read fast and brought up to date with `db.refreshMaterializedView(name)`.
@@ -200,6 +193,5 @@ export declare function pgDialect(opts: PgDialectOptions): Dialect;
200
193
  * ```
201
194
  */
202
195
  export declare function materializedView<TName extends string, C extends Record<string, ColumnBuilder>>(name: TName, columns: C, options: MaterializedViewOptions<C>): ViewDecl<TName, C, undefined> & TypedColumnRefs<C>;
203
- //#endregion
204
196
  export { PgAdapterOptions, PgClientLike, PgPoolLike, PolicyDecl, RoleDecl, isRole, pgAdapter, pgRole, policy };
205
197
  //# sourceMappingURL=pg.d.mts.map
package/dist/pg.d.mts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"pg.d.mts","names":["KyselyDialect"],"sources":["../src/dsl/columns/pg.ts","../src/dsl/pg-schema.ts","../src/adapters/pg/dialect.ts","../src/dsl/pg-views.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BiB,cAAc,sBAAsB;MAC/C,oBAAoB,OAAO;;WAEtB,UAAU;;WAEV,QAAQ;;;qBAIN,oBACX,sBACA,2CACQ,cAAc;;WAEb,UAAU;;WAEV,QAAQ;EAEjB,YAAY,UAAU,OAAO,QAAQ;;;;;;;;;wBAuBvB,OAAO,4BAA4B,gDACjD,MAAM,UACH,QAAQ,UACV,cAAc,OAAO;;wBAUR,YAAY;;;;;;;qBAUf,qBAAqB,WAAW,oBAAoB;;wBAgBjD,OAAO,eAAe;;wBAKtB,QAAQ,eAAe;;iBAKtB;EACf;EACA;;;wBAcc,SAAS,qBAAqB;;;;;;;wBAc9B,SAAS,eAAe,gBAAgB;;wBAMxC,WAAW;;wBAKX,YAAY;;wBAKZ,UAAU;;wBAKV,SAAS;;wBAKT,QAAQ;;wBAKR,QAAQ;;wBAKR,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC5JN,SAAS;WACf;;WAEA;EAET,MAAM,sBAAsB,UAAU,eAAe,gBACnD,MAAM,OACN,SAAS,IAAI,cAAc,IAC3B,UAAU,aAAa,KACtB,UAAU,OAAO,GAAG,WAAW,gBAAgB;;;;;;;;;;;;;;KAe/C,gBAAgB,wBAAwB,qCAAqC;;;;;;;wBAWlE,SAAS,sBAAsB,MAAM,QAAQ,SAAS,gBAAgB;wBA6BtE,WAAW,iBAAiB,SAAS;;;iBCnFpC;;;;;;EAMf,MAAM;;;;;EAKN;;;;;;;;;;;;;;;;;;;;;wBAsBc,UAAU,MAAM,mBAAmBA;;;;;;;;;;;;;;;;;;wBC1BnC,iBAAiB,sBAAsB,UAAU,eAAe,gBAC9E,MAAM,OACN,SAAS,GACT,SAAS,wBAAwB,KAChC,SAAS,OAAO,gBAAgB,gBAAgB"}
1
+ {"version":3,"file":"pg.d.mts","names":["KyselyDialect"],"sources":["../src/dsl/columns/pg.ts","../src/dsl/pg-schema.ts","../src/adapters/pg/dialect.ts","../src/dsl/pg-views.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BiB,cAAc,sBAAsB;MAC/C,oBAAoB,OAAO;;WAEtB,UAAU;;WAEV,QAAQ;;;qBAIN,oBACX,sBACA,2CACQ,cAAc;;WAEb,UAAU;;WAEV,QAAQ;EAEjB,YAAY,UAAU,OAAO,QAAQ;;;;;;;;;wBAuBvB,OAAO,4BAA4B,gDACjD,MAAM,UACH,QAAQ,UACV,cAAc,OAAO;;wBAUR,YAAY;;;;;;;qBAUf,qBAAqB,WAAW,oBAAoB;;wBAgBjD,OAAO,eAAe;;wBAKtB,QAAQ,eAAe;;iBAKtB;EACf;EACA;;;wBAcc,SAAS,qBAAqB;;;;;;;wBAc9B,SAAS,eAAe,gBAAgB;;wBAMxC,WAAW;;wBAKX,YAAY;;wBAKZ,UAAU;;wBAKV,SAAS;;wBAKT,QAAQ;;wBAKR,QAAQ;;wBAKR,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC5JN,SAAS;WACf;;WAEA;EAET,MAAM,sBAAsB,UAAU,eAAe,gBACnD,MAAM,OACN,SAAS,IAAI,cAAc,IAC3B,UAAU,aAAa,KACtB,UAAU,OAAO,GAAG,WAAW,gBAAgB;;;;;;;;;;;;;;KAe/C,gBAAgB,wBAAwB,qCAAqC;;;;;;;wBAWlE,SAAS,sBAAsB,MAAM,QAAQ,SAAS,gBAAgB;wBA6BtE,WAAW,iBAAiB,SAAS;iBCnFpC;;;;;;EAMf,MAAM;;;;;EAKN;;;;;;;;;;;;;;;;;;;;;wBAsBc,UAAU,MAAM,mBAAmBA;;;;;;;;;;;;;;;;wBC1BnC,iBAAiB,sBAAsB,UAAU,eAAe,gBAC9E,MAAM,OACN,SAAS,GACT,SAAS,wBAAwB,KAChC,SAAS,OAAO,gBAAgB,gBAAgB"}
package/dist/pg.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @forinda/kickjs-db v8.12.4
2
+ * @forinda/kickjs-db v8.13.0
3
3
  *
4
4
  * Copyright (c) Felix Orinda
5
5
  *
@@ -8,7 +8,7 @@
8
8
  *
9
9
  * @license MIT
10
10
  */
11
- import{_t as buildView,a as markDialect,b as introspectPg,ft as PolicyDecl,gt as policy,ht as pgRole,mt as isRole,pt as RoleDecl,ut as KickDbError}from"./create-NrvNUwZr.mjs";import{B as isPgSchema,Ft as lockTableDdl,It as lockTableName,Lt as migrationsTableDdl,Rt as pushTableName,V as pgSchema,zt as quoteTable}from"./src-BkewQb59.mjs";import{a as geometry,c as macaddr,d as pgEnum,f as point,h as xml,i as citext,l as macaddr8,m as vector,n as PgEnumColumnBuilder,o as halfvec,p as tsvector,r as cidr,s as inet,t as PgCodecColumnBuilder,u as money}from"./pg-lghOiA3k.mjs";import{Kysely,PostgresDialect}from"kysely";function pgDialect(opts){return markDialect(new PostgresDialect({pool:opts.pool,...opts.cursor?{cursor:opts.cursor}:{}}),`postgres`)}const SAFE_SCHEMA_NAME=/^[a-z_][a-z0-9_]*$/i;function pgAdapter(opts){if(opts.endPoolOnClose&&typeof opts.pool.end!=`function`)throw new KickDbError(`KICK_DB_POOL_NOT_CLOSABLE`,`pgAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close`);let dialect=`postgres`,{pool}=opts,schema=opts.schema??`public`;if(!SAFE_SCHEMA_NAME.test(schema))throw Error(`Invalid PG schema name: ${schema}`);let table=opts.migrationsTable??`kick_migrations`,T=quoteTable(dialect,table),L=quoteTable(dialect,lockTableName(table)),bookkeepingTables=(table.includes(`.`)?table.slice(0,table.lastIndexOf(`.`)):schema)===schema?[table,lockTableName(table),pushTableName(table)].map(t=>t.slice(t.lastIndexOf(`.`)+1)):[],migrationDb;return{dialect,async ensureMigrationTables(){await pool.query(migrationsTableDdl(dialect,table)),await pool.query(lockTableDdl(dialect,table))},async listApplied(){return(await pool.query(`SELECT id, name, hash, batch, applied_at, direction
11
+ import{a as geometry,c as macaddr,d as pgEnum,f as point,h as xml,i as citext,l as macaddr8,m as vector,n as PgEnumColumnBuilder,o as halfvec,p as tsvector,r as cidr,s as inet,t as PgCodecColumnBuilder,u as money}from"./pg-0Zp1q4gP.mjs";import{B as isPgSchema,Ft as lockTableDdl,It as lockTableName,Lt as migrationsTableDdl,Rt as pushTableName,V as pgSchema,zt as quoteTable}from"./src-CBTegE76.mjs";import{_t as buildView,a as markDialect,b as introspectPg,ft as PolicyDecl,gt as policy,ht as pgRole,mt as isRole,pt as RoleDecl,ut as KickDbError}from"./create-BGFj2wGn.mjs";import{Kysely,PostgresDialect}from"kysely";function pgDialect(opts){return markDialect(new PostgresDialect({pool:opts.pool,...opts.cursor?{cursor:opts.cursor}:{}}),`postgres`)}const SAFE_SCHEMA_NAME=/^[a-z_][a-z0-9_]*$/i;function pgAdapter(opts){if(opts.endPoolOnClose&&typeof opts.pool.end!=`function`)throw new KickDbError(`KICK_DB_POOL_NOT_CLOSABLE`,`pgAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close`);let dialect=`postgres`,{pool}=opts,schema=opts.schema??`public`;if(!SAFE_SCHEMA_NAME.test(schema))throw Error(`Invalid PG schema name: ${schema}`);let table=opts.migrationsTable??`kick_migrations`,T=quoteTable(dialect,table),L=quoteTable(dialect,lockTableName(table)),bookkeepingTables=(table.includes(`.`)?table.slice(0,table.lastIndexOf(`.`)):schema)===schema?[table,lockTableName(table),pushTableName(table)].map(t=>t.slice(t.lastIndexOf(`.`)+1)):[],migrationDb;return{dialect,async ensureMigrationTables(){await pool.query(migrationsTableDdl(dialect,table)),await pool.query(lockTableDdl(dialect,table))},async listApplied(){return(await pool.query(`SELECT id, name, hash, batch, applied_at, direction
12
12
  FROM ${T}
13
13
  ORDER BY applied_at ASC, id ASC`)).rows.map(row=>({id:row.id,name:row.name,hash:row.hash,batch:Number(row.batch),appliedAt:row.applied_at instanceof Date?row.applied_at.toISOString():String(row.applied_at),direction:row.direction}))},async recordApplied(row){await pool.query(`INSERT INTO ${T} (id, name, hash, batch, direction)
14
14
  VALUES ($1, $2, $3, $4, $5)`,[row.id,row.name,row.hash,row.batch,row.direction])},async removeApplied(id){await pool.query(`DELETE FROM ${T} WHERE id = $1`,[id])},async acquireLock(owner,staleAfterSeconds){return(staleAfterSeconds===void 0?await pool.query(`UPDATE ${L}
package/dist/pg.mjs.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"pg.mjs","names":[],"sources":["../src/adapters/pg/dialect.ts","../src/adapters/pg/adapter.ts","../src/dsl/pg-views.ts"],"sourcesContent":["// pgDialect — thin factory over Kysely's PostgresDialect so adopters\n// never have to write `import { PostgresDialect } from 'kysely'`.\n// Kysely is a pinned internal dep of the framework; surfacing it\n// through our own export keeps the adopter import surface stable\n// even when we change query backends (or fork Kysely's internals).\n\nimport { PostgresDialect, type Dialect as KyselyDialect } from 'kysely'\nimport { markDialect } from '../../dialect-marker'\n\nimport type { PgPoolLike } from './adapter'\n\nexport interface PgDialectOptions {\n /**\n * pg-protocol-compatible pool. Both `pg.Pool` and\n * `@neondatabase/serverless`'s Pool match structurally; adopters\n * pick whichever runtime fits.\n */\n pool: PgPoolLike\n /**\n * `pg-cursor`'s `Cursor` class, for `.stream()`: rows arrive in chunks\n * instead of all at once. `import Cursor from 'pg-cursor'`.\n */\n cursor?: unknown\n}\n\n/**\n * Construct the dialect that `createDbClient({ dialect })` consumes.\n *\n * @example\n * ```ts\n * import { createDbClient } from '@forinda/kickjs-db'\n * import { pgDialect, pgAdapter } from '@forinda/kickjs-db/pg'\n * import { Pool } from 'pg'\n *\n * const pool = new Pool({ connectionString: process.env.DATABASE_URL })\n *\n * export const db = createDbClient({\n * schema,\n * dialect: pgDialect({ pool }),\n * })\n *\n * export const migrationAdapter = pgAdapter({ pool })\n * ```\n */\nexport function pgDialect(opts: PgDialectOptions): KyselyDialect {\n // PostgresDialect's `pool` parameter is typed as `PG.Pool` in newer\n // Kysely versions; casting through `unknown` keeps adopters using\n // alternate clients (neon, pg-cloudflare) compatible without\n // pulling node-postgres' typings into our public surface.\n return markDialect(\n new PostgresDialect({\n pool: opts.pool as unknown as never,\n ...(opts.cursor ? { cursor: opts.cursor as never } : {}),\n }),\n 'postgres',\n )\n}\n","import { Kysely } from 'kysely'\nimport { pgDialect } from './dialect'\nimport {\n introspectPg,\n KickDbError,\n lockTableDdl,\n lockTableName,\n pushTableName,\n quoteTable,\n KICK_MIGRATIONS_TABLE,\n migrationsTableDdl,\n type Dialect,\n type MigrationAdapter,\n type MigrationBookkeeping,\n type MigrationRow,\n type SchemaSnapshot,\n} from '../../index'\n\n/**\n * Minimal client returned by PgPoolLike.connect(). Matches the shape of\n * pg.PoolClient and @neondatabase/serverless's PoolClient.\n */\nexport interface PgClientLike {\n query<R = unknown>(\n sql: string,\n params?: readonly unknown[],\n ): Promise<{ rows: R[]; rowCount: number | null }>\n release(): void\n}\n\n/**\n * Pool-shaped contract that pgAdapter consumes. Both `pg.Pool` and\n * `@neondatabase/serverless`'s Pool match this structurally — no hard\n * dependency on the `pg` package. Adopters pick whichever pg-protocol-\n * compatible client fits their runtime (node-postgres / neon-serverless /\n * pg-cloudflare / etc).\n *\n * Edge runtimes with a different surface (Neon HTTP single-shot,\n * Cloudflare D1's batch-only model) have their own adapter packages that\n * implement MigrationAdapter directly — they don't reuse this shape.\n */\nexport interface PgPoolLike {\n query<R = unknown>(\n sql: string,\n params?: readonly unknown[],\n ): Promise<{ rows: R[]; rowCount: number | null }>\n connect(): Promise<PgClientLike>\n end?(): Promise<void>\n}\n\nexport interface PgAdapterOptions {\n /**\n * The table migrations are recorded in. Default `kick_migrations`; its lock\n * table is the same name plus `_lock`. On Postgres it may be schema-qualified\n * (`meta.kick_migrations`); the schema is created if missing.\n */\n migrationsTable?: string\n /**\n * A pg-protocol-compatible Pool. Concretely: pg.Pool, neon-serverless Pool,\n * any other Pool that satisfies the {@link PgPoolLike} structural shape.\n */\n pool: PgPoolLike\n /** PG schema name to scope the introspector and validate at construction. Default 'public'. */\n schema?: string\n /**\n * End the pool when the adapter closes. Set it when the adapter owns its\n * pool — a `kick.config.ts` `db.adapter()` factory that opens one for the\n * CLI — or the `kick db` command waits for idle clients to time out.\n * Default `false`: an app usually shares one pool with its client.\n */\n endPoolOnClose?: boolean\n}\n\nconst SAFE_SCHEMA_NAME = /^[a-z_][a-z0-9_]*$/i\n\n/**\n * MigrationAdapter implementation backed by node-postgres. The pool is\n * caller-owned — close() does NOT end() the pool because adopters typically\n * share a single pool across the migrationAdapter and the KickDbClient.\n *\n * Lock semantics: single-row UPDATE WHERE locked_at IS NULL on\n * kick_migrations_lock. Only the row created by ensureMigrationTables()\n * exists, so the UPDATE either flips locked_at and returns rowCount=1\n * (we won) or matches zero rows (someone else holds it).\n */\nexport function pgAdapter(opts: PgAdapterOptions): MigrationAdapter {\n if (opts.endPoolOnClose && typeof opts.pool.end !== 'function') {\n throw new KickDbError(\n 'KICK_DB_POOL_NOT_CLOSABLE',\n 'pgAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close',\n )\n }\n const dialect: Dialect = 'postgres'\n const { pool } = opts\n const schema = opts.schema ?? 'public'\n if (!SAFE_SCHEMA_NAME.test(schema)) {\n // Schema name lands inside introspection queries unparameterised so guard\n // here rather than down at the SQL boundary.\n throw new Error(`Invalid PG schema name: ${schema}`)\n }\n\n const table = opts.migrationsTable ?? KICK_MIGRATIONS_TABLE\n const T = quoteTable(dialect, table)\n const L = quoteTable(dialect, lockTableName(table))\n // Introspection must not report the bookkeeping tables as schema.\n // Postgres reads a dotted name as schema.table. Introspection reads one\n // schema and matches bare names, so the tables are only left out when they\n // live in that schema — elsewhere, a same-named table here is the user's.\n const bookkeepingSchema = table.includes('.') ? table.slice(0, table.lastIndexOf('.')) : schema\n const bookkeepingTables =\n bookkeepingSchema === schema\n ? [table, lockTableName(table), pushTableName(table)].map((t) =>\n t.slice(t.lastIndexOf('.') + 1),\n )\n : []\n let migrationDb: Kysely<any> | undefined\n return {\n dialect,\n\n async ensureMigrationTables() {\n await pool.query(migrationsTableDdl(dialect, table))\n await pool.query(lockTableDdl(dialect, table))\n },\n\n async listApplied(): Promise<MigrationRow[]> {\n const r = await pool.query<{\n id: string\n name: string\n hash: string\n batch: number | string\n applied_at: string | Date\n direction: 'up' | 'down'\n }>(\n `SELECT id, name, hash, batch, applied_at, direction\n FROM ${T}\n ORDER BY applied_at ASC, id ASC`,\n )\n return r.rows.map((row) => ({\n id: row.id,\n name: row.name,\n hash: row.hash,\n batch: Number(row.batch),\n appliedAt:\n row.applied_at instanceof Date ? row.applied_at.toISOString() : String(row.applied_at),\n direction: row.direction,\n }))\n },\n\n async recordApplied(row) {\n await pool.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES ($1, $2, $3, $4, $5)`,\n [row.id, row.name, row.hash, row.batch, row.direction],\n )\n },\n\n async removeApplied(id: string) {\n await pool.query(`DELETE FROM ${T} WHERE id = $1`, [id])\n },\n\n async acquireLock(owner: string, staleAfterSeconds?: number): Promise<boolean> {\n const r =\n staleAfterSeconds === undefined\n ? await pool.query(\n `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = $1\n WHERE id = 1 AND locked_at IS NULL`,\n [owner],\n )\n : await pool.query(\n `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = $1\n WHERE id = 1 AND (locked_at IS NULL\n OR locked_at < CURRENT_TIMESTAMP - $2::int * INTERVAL '1 second')`,\n [owner, staleAfterSeconds],\n )\n return r.rowCount === 1\n },\n\n async refreshLock(owner: string) {\n const r = await pool.query(\n `UPDATE ${L} SET locked_at = CURRENT_TIMESTAMP WHERE id = 1 AND locked_by = $1`,\n [owner],\n )\n return r.rowCount === 1\n },\n\n async releaseLock(owner?: string) {\n await pool.query(\n `UPDATE ${L}\n SET locked_at = NULL, locked_by = NULL\n WHERE id = 1 AND ($1::text IS NULL OR locked_by = $1)`,\n [owner ?? null],\n )\n },\n\n async lockHolder() {\n const r = await pool.query<{ locked_by: string | null }>(\n `SELECT locked_by FROM ${L} WHERE id = 1 AND locked_at IS NOT NULL`,\n )\n return r.rows[0]?.locked_by ?? null\n },\n\n async applySqlInTx(sql: string) {\n await this.applyMigrationInTx!(sql, null)\n },\n\n async applyMigrationInTx(sql: string, bookkeeping: MigrationBookkeeping | null) {\n const client = await pool.connect()\n try {\n await client.query('BEGIN')\n await client.query(sql)\n if (bookkeeping && 'record' in bookkeeping) {\n const r = bookkeeping.record\n await client.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES ($1, $2, $3, $4, $5)`,\n [r.id, r.name, r.hash, r.batch, r.direction],\n )\n } else if (bookkeeping) {\n await client.query(`DELETE FROM ${T} WHERE id = $1`, [bookkeeping.remove])\n }\n await client.query('COMMIT')\n } catch (err) {\n await client.query('ROLLBACK').catch(() => {\n /* swallow rollback errors; we're already throwing the original */\n })\n throw err\n } finally {\n client.release()\n }\n },\n\n async applySqlNoTx(sql: string) {\n await pool.query(sql)\n },\n\n async introspect(): Promise<SchemaSnapshot> {\n return introspectPg(pool, { schema, excludeTables: bookkeepingTables })\n },\n\n migrationsTable: table,\n\n kysely() {\n // Built once, on the same connection. Never destroyed here: the pool or\n // handle belongs to the caller (or to close()).\n return (migrationDb ??= new Kysely<any>({ dialect: pgDialect({ pool: pool as never }) }))\n },\n\n async close() {\n // The caller owns the pool unless it said otherwise — adopters\n // typically share it with the KickDbClient.\n if (opts.endPoolOnClose) await opts.pool.end?.()\n },\n }\n}\n","import type { ColumnBuilder, TypedColumnRefs } from './columns/types'\nimport { buildView, type MaterializedViewOptions, type ViewDecl } from './view'\n\n/**\n * A materialized view (Postgres): the `SELECT`'s result stored as a table,\n * read fast and brought up to date with `db.refreshMaterializedView(name)`.\n *\n * ```ts\n * export const dailySales = materializedView(\n * 'daily_sales',\n * { day: date().notNull(), total: numeric(12, 2, { mode: 'number' }).notNull() },\n * {\n * as: `SELECT created_at::date AS day, sum(amount) AS total FROM orders GROUP BY 1`,\n * constraints: (t) => ({ byDay: unique('daily_sales_day').on(t.day) }),\n * },\n * )\n * ```\n */\nexport function materializedView<TName extends string, C extends Record<string, ColumnBuilder>>(\n name: TName,\n columns: C,\n options: MaterializedViewOptions<C>,\n): ViewDecl<TName, C, undefined> & TypedColumnRefs<C> {\n return buildView(name, columns, options.as, true, options.constraints, undefined)\n}\n"],"mappings":"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"}
1
+ {"version":3,"file":"pg.mjs","names":[],"sources":["../src/adapters/pg/dialect.ts","../src/adapters/pg/adapter.ts","../src/dsl/pg-views.ts"],"sourcesContent":["// pgDialect — thin factory over Kysely's PostgresDialect so adopters\n// never have to write `import { PostgresDialect } from 'kysely'`.\n// Kysely is a pinned internal dep of the framework; surfacing it\n// through our own export keeps the adopter import surface stable\n// even when we change query backends (or fork Kysely's internals).\n\nimport { PostgresDialect, type Dialect as KyselyDialect } from 'kysely'\nimport { markDialect } from '../../dialect-marker'\n\nimport type { PgPoolLike } from './adapter'\n\nexport interface PgDialectOptions {\n /**\n * pg-protocol-compatible pool. Both `pg.Pool` and\n * `@neondatabase/serverless`'s Pool match structurally; adopters\n * pick whichever runtime fits.\n */\n pool: PgPoolLike\n /**\n * `pg-cursor`'s `Cursor` class, for `.stream()`: rows arrive in chunks\n * instead of all at once. `import Cursor from 'pg-cursor'`.\n */\n cursor?: unknown\n}\n\n/**\n * Construct the dialect that `createDbClient({ dialect })` consumes.\n *\n * @example\n * ```ts\n * import { createDbClient } from '@forinda/kickjs-db'\n * import { pgDialect, pgAdapter } from '@forinda/kickjs-db/pg'\n * import { Pool } from 'pg'\n *\n * const pool = new Pool({ connectionString: process.env.DATABASE_URL })\n *\n * export const db = createDbClient({\n * schema,\n * dialect: pgDialect({ pool }),\n * })\n *\n * export const migrationAdapter = pgAdapter({ pool })\n * ```\n */\nexport function pgDialect(opts: PgDialectOptions): KyselyDialect {\n // PostgresDialect's `pool` parameter is typed as `PG.Pool` in newer\n // Kysely versions; casting through `unknown` keeps adopters using\n // alternate clients (neon, pg-cloudflare) compatible without\n // pulling node-postgres' typings into our public surface.\n return markDialect(\n new PostgresDialect({\n pool: opts.pool as unknown as never,\n ...(opts.cursor ? { cursor: opts.cursor as never } : {}),\n }),\n 'postgres',\n )\n}\n","import { Kysely } from 'kysely'\nimport { pgDialect } from './dialect'\nimport {\n introspectPg,\n KickDbError,\n lockTableDdl,\n lockTableName,\n pushTableName,\n quoteTable,\n KICK_MIGRATIONS_TABLE,\n migrationsTableDdl,\n type Dialect,\n type MigrationAdapter,\n type MigrationBookkeeping,\n type MigrationRow,\n type SchemaSnapshot,\n} from '../../index'\n\n/**\n * Minimal client returned by PgPoolLike.connect(). Matches the shape of\n * pg.PoolClient and @neondatabase/serverless's PoolClient.\n */\nexport interface PgClientLike {\n query<R = unknown>(\n sql: string,\n params?: readonly unknown[],\n ): Promise<{ rows: R[]; rowCount: number | null }>\n release(): void\n}\n\n/**\n * Pool-shaped contract that pgAdapter consumes. Both `pg.Pool` and\n * `@neondatabase/serverless`'s Pool match this structurally — no hard\n * dependency on the `pg` package. Adopters pick whichever pg-protocol-\n * compatible client fits their runtime (node-postgres / neon-serverless /\n * pg-cloudflare / etc).\n *\n * Edge runtimes with a different surface (Neon HTTP single-shot,\n * Cloudflare D1's batch-only model) have their own adapter packages that\n * implement MigrationAdapter directly — they don't reuse this shape.\n */\nexport interface PgPoolLike {\n query<R = unknown>(\n sql: string,\n params?: readonly unknown[],\n ): Promise<{ rows: R[]; rowCount: number | null }>\n connect(): Promise<PgClientLike>\n end?(): Promise<void>\n}\n\nexport interface PgAdapterOptions {\n /**\n * The table migrations are recorded in. Default `kick_migrations`; its lock\n * table is the same name plus `_lock`. On Postgres it may be schema-qualified\n * (`meta.kick_migrations`); the schema is created if missing.\n */\n migrationsTable?: string\n /**\n * A pg-protocol-compatible Pool. Concretely: pg.Pool, neon-serverless Pool,\n * any other Pool that satisfies the {@link PgPoolLike} structural shape.\n */\n pool: PgPoolLike\n /** PG schema name to scope the introspector and validate at construction. Default 'public'. */\n schema?: string\n /**\n * End the pool when the adapter closes. Set it when the adapter owns its\n * pool — a `kick.config.ts` `db.adapter()` factory that opens one for the\n * CLI — or the `kick db` command waits for idle clients to time out.\n * Default `false`: an app usually shares one pool with its client.\n */\n endPoolOnClose?: boolean\n}\n\nconst SAFE_SCHEMA_NAME = /^[a-z_][a-z0-9_]*$/i\n\n/**\n * MigrationAdapter implementation backed by node-postgres. The pool is\n * caller-owned — close() does NOT end() the pool because adopters typically\n * share a single pool across the migrationAdapter and the KickDbClient.\n *\n * Lock semantics: single-row UPDATE WHERE locked_at IS NULL on\n * kick_migrations_lock. Only the row created by ensureMigrationTables()\n * exists, so the UPDATE either flips locked_at and returns rowCount=1\n * (we won) or matches zero rows (someone else holds it).\n */\nexport function pgAdapter(opts: PgAdapterOptions): MigrationAdapter {\n if (opts.endPoolOnClose && typeof opts.pool.end !== 'function') {\n throw new KickDbError(\n 'KICK_DB_POOL_NOT_CLOSABLE',\n 'pgAdapter({ endPoolOnClose: true }) needs a pool with an end() method to close',\n )\n }\n const dialect: Dialect = 'postgres'\n const { pool } = opts\n const schema = opts.schema ?? 'public'\n if (!SAFE_SCHEMA_NAME.test(schema)) {\n // Schema name lands inside introspection queries unparameterised so guard\n // here rather than down at the SQL boundary.\n throw new Error(`Invalid PG schema name: ${schema}`)\n }\n\n const table = opts.migrationsTable ?? KICK_MIGRATIONS_TABLE\n const T = quoteTable(dialect, table)\n const L = quoteTable(dialect, lockTableName(table))\n // Introspection must not report the bookkeeping tables as schema.\n // Postgres reads a dotted name as schema.table. Introspection reads one\n // schema and matches bare names, so the tables are only left out when they\n // live in that schema — elsewhere, a same-named table here is the user's.\n const bookkeepingSchema = table.includes('.') ? table.slice(0, table.lastIndexOf('.')) : schema\n const bookkeepingTables =\n bookkeepingSchema === schema\n ? [table, lockTableName(table), pushTableName(table)].map((t) =>\n t.slice(t.lastIndexOf('.') + 1),\n )\n : []\n let migrationDb: Kysely<any> | undefined\n return {\n dialect,\n\n async ensureMigrationTables() {\n await pool.query(migrationsTableDdl(dialect, table))\n await pool.query(lockTableDdl(dialect, table))\n },\n\n async listApplied(): Promise<MigrationRow[]> {\n const r = await pool.query<{\n id: string\n name: string\n hash: string\n batch: number | string\n applied_at: string | Date\n direction: 'up' | 'down'\n }>(\n `SELECT id, name, hash, batch, applied_at, direction\n FROM ${T}\n ORDER BY applied_at ASC, id ASC`,\n )\n return r.rows.map((row) => ({\n id: row.id,\n name: row.name,\n hash: row.hash,\n batch: Number(row.batch),\n appliedAt:\n row.applied_at instanceof Date ? row.applied_at.toISOString() : String(row.applied_at),\n direction: row.direction,\n }))\n },\n\n async recordApplied(row) {\n await pool.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES ($1, $2, $3, $4, $5)`,\n [row.id, row.name, row.hash, row.batch, row.direction],\n )\n },\n\n async removeApplied(id: string) {\n await pool.query(`DELETE FROM ${T} WHERE id = $1`, [id])\n },\n\n async acquireLock(owner: string, staleAfterSeconds?: number): Promise<boolean> {\n const r =\n staleAfterSeconds === undefined\n ? await pool.query(\n `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = $1\n WHERE id = 1 AND locked_at IS NULL`,\n [owner],\n )\n : await pool.query(\n `UPDATE ${L}\n SET locked_at = CURRENT_TIMESTAMP, locked_by = $1\n WHERE id = 1 AND (locked_at IS NULL\n OR locked_at < CURRENT_TIMESTAMP - $2::int * INTERVAL '1 second')`,\n [owner, staleAfterSeconds],\n )\n return r.rowCount === 1\n },\n\n async refreshLock(owner: string) {\n const r = await pool.query(\n `UPDATE ${L} SET locked_at = CURRENT_TIMESTAMP WHERE id = 1 AND locked_by = $1`,\n [owner],\n )\n return r.rowCount === 1\n },\n\n async releaseLock(owner?: string) {\n await pool.query(\n `UPDATE ${L}\n SET locked_at = NULL, locked_by = NULL\n WHERE id = 1 AND ($1::text IS NULL OR locked_by = $1)`,\n [owner ?? null],\n )\n },\n\n async lockHolder() {\n const r = await pool.query<{ locked_by: string | null }>(\n `SELECT locked_by FROM ${L} WHERE id = 1 AND locked_at IS NOT NULL`,\n )\n return r.rows[0]?.locked_by ?? null\n },\n\n async applySqlInTx(sql: string) {\n await this.applyMigrationInTx!(sql, null)\n },\n\n async applyMigrationInTx(sql: string, bookkeeping: MigrationBookkeeping | null) {\n const client = await pool.connect()\n try {\n await client.query('BEGIN')\n await client.query(sql)\n if (bookkeeping && 'record' in bookkeeping) {\n const r = bookkeeping.record\n await client.query(\n `INSERT INTO ${T} (id, name, hash, batch, direction)\n VALUES ($1, $2, $3, $4, $5)`,\n [r.id, r.name, r.hash, r.batch, r.direction],\n )\n } else if (bookkeeping) {\n await client.query(`DELETE FROM ${T} WHERE id = $1`, [bookkeeping.remove])\n }\n await client.query('COMMIT')\n } catch (err) {\n await client.query('ROLLBACK').catch(() => {\n /* swallow rollback errors; we're already throwing the original */\n })\n throw err\n } finally {\n client.release()\n }\n },\n\n async applySqlNoTx(sql: string) {\n await pool.query(sql)\n },\n\n async introspect(): Promise<SchemaSnapshot> {\n return introspectPg(pool, { schema, excludeTables: bookkeepingTables })\n },\n\n migrationsTable: table,\n\n kysely() {\n // Built once, on the same connection. Never destroyed here: the pool or\n // handle belongs to the caller (or to close()).\n return (migrationDb ??= new Kysely<any>({ dialect: pgDialect({ pool: pool as never }) }))\n },\n\n async close() {\n // The caller owns the pool unless it said otherwise — adopters\n // typically share it with the KickDbClient.\n if (opts.endPoolOnClose) await opts.pool.end?.()\n },\n }\n}\n","import type { ColumnBuilder, TypedColumnRefs } from './columns/types'\nimport { buildView, type MaterializedViewOptions, type ViewDecl } from './view'\n\n/**\n * A materialized view (Postgres): the `SELECT`'s result stored as a table,\n * read fast and brought up to date with `db.refreshMaterializedView(name)`.\n *\n * ```ts\n * export const dailySales = materializedView(\n * 'daily_sales',\n * { day: date().notNull(), total: numeric(12, 2, { mode: 'number' }).notNull() },\n * {\n * as: `SELECT created_at::date AS day, sum(amount) AS total FROM orders GROUP BY 1`,\n * constraints: (t) => ({ byDay: unique('daily_sales_day').on(t.day) }),\n * },\n * )\n * ```\n */\nexport function materializedView<TName extends string, C extends Record<string, ColumnBuilder>>(\n name: TName,\n columns: C,\n options: MaterializedViewOptions<C>,\n): ViewDecl<TName, C, undefined> & TypedColumnRefs<C> {\n return buildView(name, columns, options.as, true, options.constraints, undefined)\n}\n"],"mappings":"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"}
package/dist/pglite.d.mts CHANGED
@@ -1,6 +1,5 @@
1
1
 
2
- import { r as PgPoolLike } from "./adapter-cVrkWrul.mjs";
3
- //#region src/pglite.d.ts
2
+ import { r as PgPoolLike } from "./adapter-HRQJb4xQ.mjs";
4
3
  /** PGlite's results have pg's shape — `rows`, `rowCount`, `command` — from 0.5.5. */
5
4
  type PgResult = {
6
5
  rows: any[];
@@ -34,6 +33,5 @@ export interface PGliteLike {
34
33
  * `end()` closes the database. `.stream()` isn't supported: it needs `pg-cursor`.
35
34
  */
36
35
  export declare function pglitePool(db: PGliteLike): PgPoolLike;
37
- //#endregion
38
36
  export {};
39
37
  //# sourceMappingURL=pglite.d.mts.map
@@ -1 +1 @@
1
- {"version":3,"file":"pglite.d.mts","names":[],"sources":["../src/pglite.ts"],"mappings":";;;;KAMK;EAAa;EAAa;EAA0B;EAAuB;;;iBAG/D;EACf,MAAM,aAAa,iBAAiB,QAAQ;EAC5C,KAAK,cAAc,QAAQ;EAC3B,SAAS;;;;;;;;;;;;;;;;;;;;;wBAsBK,WAAW,IAAI,aAAa"}
1
+ {"version":3,"file":"pglite.d.mts","names":[],"sources":["../src/pglite.ts"],"mappings":";;;KAMK;EAAa;EAAa;EAA0B;EAAuB;;;iBAG/D;EACf,MAAM,aAAa,iBAAiB,QAAQ;EAC5C,KAAK,cAAc,QAAQ;EAC3B,SAAS;;;;;;;;;;;;;;;;;;;;;wBAsBK,WAAW,IAAI,aAAa"}
package/dist/pglite.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @forinda/kickjs-db v8.12.4
2
+ * @forinda/kickjs-db v8.13.0
3
3
  *
4
4
  * Copyright (c) Felix Orinda
5
5
  *