@getstrata/core 2.2.60 → 3.0.3

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 (330) hide show
  1. package/CHANGELOG.md +22 -0
  2. package/dist/core/audit/exportAuditLogs.d.ts +12 -3
  3. package/dist/core/audit/exportStore.d.ts +6 -2
  4. package/dist/core/audit/siemFormatter.d.ts +2 -2
  5. package/dist/core/auth/abilityCatalog.d.ts +1 -9
  6. package/dist/core/auth/authContext.d.ts +2 -0
  7. package/dist/core/auth/authOutcome.d.ts +32 -0
  8. package/dist/core/auth/authReader.d.ts +22 -0
  9. package/dist/core/auth/basicAuthGuard.d.ts +19 -3
  10. package/dist/core/auth/emailVerification.d.ts +1 -1
  11. package/dist/core/auth/guard.d.ts +27 -6
  12. package/dist/core/auth/intendedUrlCookie.d.ts +13 -7
  13. package/dist/core/auth/jwt.d.ts +5 -4
  14. package/dist/core/auth/jwtGuard.d.ts +7 -6
  15. package/dist/core/auth/membershipContext.d.ts +10 -7
  16. package/dist/core/auth/membershipContextMiddleware.d.ts +3 -3
  17. package/dist/core/auth/membershipMiddleware.d.ts +1 -2
  18. package/dist/core/auth/membershipServiceImplementation.d.ts +1 -1
  19. package/dist/core/auth/oauth/oidcIdToken.d.ts +25 -16
  20. package/dist/core/auth/oauth/oidcProvider.d.ts +6 -4
  21. package/dist/core/auth/oauth/providers.d.ts +3 -1
  22. package/dist/core/auth/oneTimeToken.d.ts +2 -3
  23. package/dist/core/auth/passwordConfirmCookie.d.ts +15 -6
  24. package/dist/core/auth/passwordLogin.d.ts +5 -5
  25. package/dist/core/auth/pendingMfaCookie.d.ts +2 -2
  26. package/dist/core/auth/policy.d.ts +23 -10
  27. package/dist/core/auth/requireAuthCapability.d.ts +3 -0
  28. package/dist/core/auth/resolveMembershipService.d.ts +3 -2
  29. package/dist/core/auth/saml/samlAssertionReplay.d.ts +4 -4
  30. package/dist/core/auth/saml/samlServiceProvider.d.ts +11 -7
  31. package/dist/core/auth/scimAuthMiddleware.d.ts +10 -3
  32. package/dist/core/auth/sessionCookie.d.ts +20 -9
  33. package/dist/core/auth/sessionGuard.d.ts +14 -3
  34. package/dist/core/cache/createCacheStore.d.ts +6 -3
  35. package/dist/core/cache/redisCacheStore.d.ts +5 -1
  36. package/dist/core/cache/repository.d.ts +5 -1
  37. package/dist/core/cache/simpleCache.d.ts +2 -1
  38. package/dist/core/cache/tokens.d.ts +8 -0
  39. package/dist/core/config/applicationConfig.d.ts +21 -0
  40. package/dist/core/config/configSnapshot.d.ts +3 -0
  41. package/dist/core/config/envSchema.d.ts +3 -2
  42. package/dist/core/contracts/application.d.ts +153 -0
  43. package/dist/core/contracts/authUserDirectory.d.ts +24 -7
  44. package/dist/core/contracts/container.d.ts +20 -23
  45. package/dist/core/contracts/di.d.ts +4 -2
  46. package/dist/core/contracts/executionContext.d.ts +5 -0
  47. package/dist/core/contracts/executionOperations.d.ts +10 -0
  48. package/dist/core/contracts/executionOwnership.d.ts +38 -0
  49. package/dist/core/contracts/persistence.d.ts +20 -0
  50. package/dist/core/contracts/serviceTokens.d.ts +32 -18
  51. package/dist/core/contracts/services.d.ts +63 -0
  52. package/dist/core/contracts/token.d.ts +19 -0
  53. package/dist/core/crypto/fieldEncryption.d.ts +19 -7
  54. package/dist/core/crypto/fieldEncryptionRotation.d.ts +21 -5
  55. package/dist/core/crypto/mfaSecret.d.ts +10 -3
  56. package/dist/core/database/baseRepository.d.ts +14 -10
  57. package/dist/core/database/bindings.d.ts +6 -0
  58. package/dist/core/database/bunSql.d.ts +3 -12
  59. package/dist/core/database/definitions.d.ts +209 -0
  60. package/dist/core/database/dialect.d.ts +5 -24
  61. package/dist/core/database/driverPorts.d.ts +116 -0
  62. package/dist/core/database/errors.d.ts +47 -7
  63. package/dist/core/database/factory.d.ts +51 -31
  64. package/dist/core/database/index.d.ts +9 -10
  65. package/dist/core/database/keyset.d.ts +2 -1
  66. package/dist/core/database/legacyNativeTransaction.d.ts +5 -0
  67. package/dist/core/database/manager.d.ts +12 -0
  68. package/dist/core/database/model.d.ts +91 -97
  69. package/dist/core/database/modelQuery.d.ts +9 -5
  70. package/dist/core/database/modelRegistry.d.ts +52 -33
  71. package/dist/core/database/mysqlConnection.d.ts +1 -19
  72. package/dist/core/database/mysqlNative.d.ts +38 -0
  73. package/dist/core/database/nativeTransactions.d.ts +16 -0
  74. package/dist/core/database/ormInternal.d.ts +85 -0
  75. package/dist/core/database/ormRuntime.d.ts +4 -0
  76. package/dist/core/database/ownedReadOnlyObservation.d.ts +16 -0
  77. package/dist/core/database/postgresNative.d.ts +11 -0
  78. package/dist/core/database/query.d.ts +24 -23
  79. package/dist/core/database/queryPlanSnapshot.d.ts +7 -0
  80. package/dist/core/database/rawMysql.d.ts +7 -0
  81. package/dist/core/database/rawPostgres.d.ts +23 -0
  82. package/dist/core/database/rawSqlite.d.ts +6 -0
  83. package/dist/core/database/relationQueries.d.ts +3 -2
  84. package/dist/core/database/relationQuery.d.ts +24 -6
  85. package/dist/core/database/repositoryQuery.d.ts +6 -1
  86. package/dist/core/database/schema/driver.d.ts +1 -1
  87. package/dist/core/database/seeders/types.d.ts +1 -1
  88. package/dist/core/database/session.d.ts +13 -0
  89. package/dist/core/database/sessionFactory.d.ts +9 -0
  90. package/dist/core/database/sqlDialects.d.ts +22 -0
  91. package/dist/core/database/tokens.d.ts +7 -0
  92. package/dist/core/database/transactionSession.d.ts +43 -0
  93. package/dist/core/errors/http.d.ts +4 -1
  94. package/dist/core/events/{eventBus.d.ts → eventBusClass.d.ts} +1 -3
  95. package/dist/core/events/index.d.ts +2 -3
  96. package/dist/core/events/outbox/index.d.ts +44 -13
  97. package/dist/core/events/outbox/metrics.d.ts +4 -4
  98. package/dist/core/events/outbox/workerTransport.d.ts +17 -0
  99. package/dist/core/http/authMiddleware.d.ts +2 -2
  100. package/dist/core/http/authorizeMiddleware.d.ts +2 -2
  101. package/dist/core/http/bodySizeLimitMiddleware.d.ts +1 -1
  102. package/dist/core/http/conditionalResponse.d.ts +7 -2
  103. package/dist/core/http/contentSecurityPolicy.d.ts +4 -3
  104. package/dist/core/http/corsMiddleware.d.ts +2 -1
  105. package/dist/core/http/csrfMiddleware.d.ts +6 -1
  106. package/dist/core/http/csrfToken.d.ts +17 -7
  107. package/dist/core/http/databaseError.d.ts +4 -0
  108. package/dist/core/http/etag.d.ts +5 -2
  109. package/dist/core/http/flashMiddleware.d.ts +1 -1
  110. package/dist/core/http/flashSession.d.ts +13 -7
  111. package/dist/core/http/index.d.ts +1 -1
  112. package/dist/core/http/loginThrottleMiddleware.d.ts +3 -3
  113. package/dist/core/http/memoryThrottleMiddleware.d.ts +2 -2
  114. package/dist/core/http/parseMultipartUpload.d.ts +3 -2
  115. package/dist/core/http/requestMetaContext.d.ts +5 -0
  116. package/dist/core/http/requireAbilityMiddleware.d.ts +1 -1
  117. package/dist/core/http/requireAuthMiddleware.d.ts +2 -2
  118. package/dist/core/http/requirePasswordConfirmMiddleware.d.ts +2 -1
  119. package/dist/core/http/requireVerifiedMiddleware.d.ts +2 -2
  120. package/dist/core/http/requireWebAuthMiddleware.d.ts +2 -2
  121. package/dist/core/http/response.d.ts +4 -3
  122. package/dist/core/http/scimThrottleMiddleware.d.ts +4 -3
  123. package/dist/core/http/securedRouteModelBinding.d.ts +10 -3
  124. package/dist/core/http/securityHeadersMiddleware.d.ts +1 -2
  125. package/dist/core/http/signedUrl.d.ts +8 -6
  126. package/dist/core/http/throttleMiddleware.d.ts +9 -5
  127. package/dist/core/http/uploads.d.ts +9 -3
  128. package/dist/core/http/webErrorResponse.d.ts +8 -2
  129. package/dist/core/jobs/exportAuditLogsJob.d.ts +5 -2
  130. package/dist/core/jobs/invalidateCacheTagsJob.d.ts +5 -4
  131. package/dist/core/lifecycle/gracefulShutdown.d.ts +2 -5
  132. package/dist/core/logging/requestLoggingMiddleware.d.ts +1 -1
  133. package/dist/core/mail/mailer.d.ts +7 -5
  134. package/dist/core/openapi/generator.d.ts +12 -4
  135. package/dist/core/openapi/registeredRoute.d.ts +4 -4
  136. package/dist/core/queue/createAppQueue.d.ts +9 -4
  137. package/dist/core/queue/failedJobMetrics.d.ts +11 -2
  138. package/dist/core/queue/failedJobRepository.d.ts +6 -3
  139. package/dist/core/queue/failedJobService.d.ts +1 -0
  140. package/dist/core/queue/index.d.ts +16 -6
  141. package/dist/core/queue/jobRegistry.d.ts +3 -2
  142. package/dist/core/queue/jobRunner.d.ts +10 -4
  143. package/dist/core/queue/publicQueue.d.ts +18 -9
  144. package/dist/core/queue/queueConfig.d.ts +20 -10
  145. package/dist/core/queue/queueHandoff.d.ts +31 -0
  146. package/dist/core/queue/queueMetrics.d.ts +10 -3
  147. package/dist/core/queue/queueServices.d.ts +28 -0
  148. package/dist/core/queue/queueWorkerTransport.d.ts +28 -0
  149. package/dist/core/queue/redisQueue.d.ts +19 -10
  150. package/dist/core/queue/redisQueueKeys.d.ts +5 -5
  151. package/dist/core/queue/redisStreams.d.ts +17 -10
  152. package/dist/core/queue/resilientQueue.d.ts +10 -4
  153. package/dist/core/queue/types.d.ts +1 -0
  154. package/dist/core/runtime/appKeyPrefix.d.ts +5 -5
  155. package/dist/core/runtime/application.d.ts +7 -0
  156. package/dist/core/runtime/executionContext.d.ts +9 -0
  157. package/dist/core/runtime/executionTasks.d.ts +49 -0
  158. package/dist/core/runtime/resourceJournal.d.ts +67 -0
  159. package/dist/core/runtime/serviceGraph.d.ts +14 -0
  160. package/dist/core/security/oauthState.d.ts +13 -9
  161. package/dist/core/security/publicReads.d.ts +2 -2
  162. package/dist/core/security/safeFetch.d.ts +1 -0
  163. package/dist/core/security/safeUrl.d.ts +3 -0
  164. package/dist/core/security/scimTenantTokens.d.ts +1 -1
  165. package/dist/core/security/tokenExpiry.d.ts +1 -1
  166. package/dist/core/security/webhookSignature.d.ts +1 -1
  167. package/dist/core/storage/storage.d.ts +24 -16
  168. package/dist/core/tenant/databaseTenantContext.d.ts +5 -7
  169. package/dist/core/tenant/resolveTenant.d.ts +2 -2
  170. package/dist/core/tenant/scopedDatabasePolicy.d.ts +8 -0
  171. package/dist/core/tenant/tenantDatabaseScope.d.ts +3 -7
  172. package/dist/core/tenant/tenantMiddleware.d.ts +15 -4
  173. package/dist/core/tracing/otel.d.ts +4 -6
  174. package/dist/core/tracing/tracingMiddleware.d.ts +3 -3
  175. package/dist/core/view/etaViewEngine.d.ts +1 -1
  176. package/dist/core/view/index.d.ts +5 -4
  177. package/dist/core/view/tokens.d.ts +8 -0
  178. package/dist/core/view/viewRenderer.d.ts +2 -2
  179. package/dist/core/view/webErrorView.d.ts +8 -7
  180. package/dist/core/view/webLayoutData.d.ts +6 -4
  181. package/dist/entries/audit/exportAuditLogs.js +87 -1024
  182. package/dist/entries/audit/siemFormatter.js +4 -90
  183. package/dist/entries/auth/abilityCatalog.js +28 -0
  184. package/dist/entries/auth/accessControl.js +5 -16
  185. package/dist/entries/auth/accountStateMigration.js +216 -236
  186. package/dist/entries/auth/authOutcome.js +80 -0
  187. package/dist/entries/auth/authReader.js +68 -0
  188. package/dist/entries/auth/basicAuthGuard.js +144 -1249
  189. package/dist/entries/auth/emailVerification.js +2 -2
  190. package/dist/entries/auth/intendedUrlCookie.js +35 -59
  191. package/dist/entries/auth/jwt.js +22 -47
  192. package/dist/entries/auth/jwtGuard.js +99 -231
  193. package/dist/entries/auth/membershipMiddleware.js +71 -10
  194. package/dist/entries/auth/membershipScope.js +16 -22
  195. package/dist/entries/auth/membershipService.js +11 -28
  196. package/dist/entries/auth/oauth/oidcProvider.js +59 -64
  197. package/dist/entries/auth/oauth/providers.js +12 -95
  198. package/dist/entries/auth/oauth/samlProvider.js +53 -1080
  199. package/dist/entries/auth/oneTimeToken.js +27 -289
  200. package/dist/entries/auth/passwordConfirmCookie.js +40 -63
  201. package/dist/entries/auth/passwordLogin.js +94 -399
  202. package/dist/entries/auth/pendingMfaCookie.js +6 -6
  203. package/dist/entries/auth/policy.js +22 -56
  204. package/dist/entries/auth/saml/samlServiceProvider.js +55 -1084
  205. package/dist/entries/auth/scimAuthMiddleware.js +16 -3358
  206. package/dist/entries/auth/sessionCookie.js +58 -73
  207. package/dist/entries/auth/sessionGuard.js +95 -248
  208. package/dist/entries/auth/tokenHash.js +11 -43
  209. package/dist/entries/cache/createCacheStore.js +126 -117
  210. package/dist/entries/cache/repository.js +25 -0
  211. package/dist/entries/cache/simpleCache.js +12 -7
  212. package/dist/entries/cache/tokens.js +9 -0
  213. package/dist/entries/config/applicationConfig.js +163 -0
  214. package/dist/entries/config/envSchema.js +21 -4
  215. package/dist/entries/contracts/application.js +1 -0
  216. package/dist/entries/contracts/authUserDirectory.js +10 -0
  217. package/dist/entries/contracts/container.js +99 -26
  218. package/dist/entries/contracts/di.js +3 -0
  219. package/dist/entries/contracts/executionContext.js +7 -0
  220. package/dist/entries/contracts/executionOperations.js +7 -0
  221. package/dist/entries/contracts/executionOwnership.js +7 -0
  222. package/dist/entries/contracts/membership.js +1 -0
  223. package/dist/entries/contracts/persistence.js +1 -0
  224. package/dist/entries/contracts/serviceTokens.js +26 -116
  225. package/dist/entries/contracts/services.js +98 -0
  226. package/dist/entries/contracts/token.js +41 -0
  227. package/dist/entries/crypto/fieldEncryption.js +49 -50
  228. package/dist/entries/crypto/mfaSecret.js +86 -82
  229. package/dist/entries/database/acquisitionMetrics.js +107 -0
  230. package/dist/entries/database/baseRepository.d.ts +2 -0
  231. package/dist/entries/database/bindings.js +2082 -0
  232. package/dist/entries/database/definitions.js +175 -0
  233. package/dist/entries/database/errors.js +114 -89
  234. package/dist/entries/database/factory.js +67 -28
  235. package/dist/entries/database/migrations.js +172 -224
  236. package/dist/entries/database/model.d.ts +1 -0
  237. package/dist/entries/database/ownedReadOnlyObservation.js +1282 -0
  238. package/dist/entries/database/query.js +159 -161
  239. package/dist/entries/database/repositoryQuery.d.ts +1 -0
  240. package/dist/entries/database/repositoryQuery.js +1 -1373
  241. package/dist/entries/database/schema.js +216 -236
  242. package/dist/entries/database/session.js +1 -0
  243. package/dist/entries/database/sqliteConnection.js +525 -83
  244. package/dist/entries/database/tokens.js +9 -0
  245. package/dist/entries/errors/http.js +118 -1
  246. package/dist/entries/http/authMiddleware.js +8 -5
  247. package/dist/entries/http/authorizeMiddleware.js +1 -1
  248. package/dist/entries/http/bodySizeLimitMiddleware.js +2 -2
  249. package/dist/entries/http/clientIp.js +2 -2
  250. package/dist/entries/http/conditionalResponse.js +19 -7
  251. package/dist/entries/http/corsMiddleware.js +6 -101
  252. package/dist/entries/http/csrfMiddleware.js +92 -106
  253. package/dist/entries/http/csrfToken.js +58 -94
  254. package/dist/entries/http/etag.js +7 -4
  255. package/dist/entries/http/flashMiddleware.js +57 -99
  256. package/dist/entries/http/flashSession.js +41 -68
  257. package/dist/entries/http/memoryThrottleMiddleware.js +43 -186
  258. package/dist/entries/http/metricsMiddleware.js +2 -16
  259. package/dist/entries/http/parseMultipartUpload.js +15 -29
  260. package/dist/entries/http/requireAbilityMiddleware.js +2 -2
  261. package/dist/entries/http/requirePasswordConfirmMiddleware.js +19 -31
  262. package/dist/entries/http/requireVerifiedMiddleware.js +4 -7
  263. package/dist/entries/http/requireWebAuthMiddleware.js +2 -2
  264. package/dist/entries/http/response.js +67 -233
  265. package/dist/entries/http/routeMiddleware.js +0 -14
  266. package/dist/entries/http/scimThrottleMiddleware.js +43 -237
  267. package/dist/entries/http/securedRouteModelBinding.js +37 -25
  268. package/dist/entries/http/securityHeadersMiddleware.js +8 -25
  269. package/dist/entries/http/signedUrl.js +20 -110
  270. package/dist/entries/http/throttleMiddleware.js +41 -185
  271. package/dist/entries/http/uploads.js +9 -24
  272. package/dist/entries/jobs/exportAuditLogsJob.js +17 -1498
  273. package/dist/entries/jobs/invalidateCacheTagsJob.js +12 -47
  274. package/dist/entries/logging/requestLoggingMiddleware.js +4 -4
  275. package/dist/entries/mail/mailer.js +68 -78
  276. package/dist/entries/openapi/generator.js +33 -100
  277. package/dist/entries/queue/createAppQueue.js +416 -256
  278. package/dist/entries/queue/failedJobRepository.js +17 -8
  279. package/dist/entries/queue/failedJobService.js +1 -0
  280. package/dist/entries/queue/jobRunner.js +141 -66
  281. package/dist/entries/queue/publicQueue.js +411 -257
  282. package/dist/entries/queue/queueConfig.js +61 -0
  283. package/dist/entries/queue/queueHandoff.js +318 -0
  284. package/dist/entries/queue/queueMetrics.js +989 -1386
  285. package/dist/entries/queue/queueServices.js +133 -0
  286. package/dist/entries/queue/queueWorkerTransport.js +1703 -0
  287. package/dist/entries/queue/redisQueue.js +282 -180
  288. package/dist/entries/queue.js +6 -45
  289. package/dist/entries/runtime/application.js +1585 -0
  290. package/dist/entries/runtime/asyncContextStore.js +0 -16
  291. package/dist/entries/security/oauthState.js +35 -67
  292. package/dist/entries/security/publicReads.js +4 -4
  293. package/dist/entries/security/safeFetch.js +1 -0
  294. package/dist/entries/security/scimTenantTokens.js +3 -3
  295. package/dist/entries/security/tokenExpiry.js +2 -2
  296. package/dist/entries/security/totp.js +1 -87
  297. package/dist/entries/security/webhookSignature.js +2 -90
  298. package/dist/entries/storage/storage.js +120 -45
  299. package/dist/entries/tenant/databaseTenantContext.js +6 -907
  300. package/dist/entries/tenant/publicTenantHost.js +78 -0
  301. package/dist/entries/tenant/resolveTenant.js +14 -0
  302. package/dist/entries/tenant/scopedDatabasePolicy.js +75 -0
  303. package/dist/entries/tenant/tenancyConfig.js +1 -19
  304. package/dist/entries/tenant/tenantDatabaseScope.js +3 -892
  305. package/dist/entries/tracing/tracingMiddleware.js +104 -173
  306. package/dist/entries/view/tokens.js +11 -0
  307. package/dist/framework/public-api.d.ts +62 -44
  308. package/dist/index.js +10435 -11351
  309. package/dist/internal/ormInternal.js +117 -0
  310. package/dist/internal/ormRuntime.js +5000 -0
  311. package/package.json +158 -46
  312. package/dist/core/database/bindConnection.d.ts +0 -1
  313. package/dist/core/database/boundConnection.d.ts +0 -5
  314. package/dist/core/database/defaultConnection.d.ts +0 -7
  315. package/dist/core/database/namedConnections.d.ts +0 -15
  316. package/dist/core/database/readOnlyCollector.d.ts +0 -7
  317. package/dist/core/database/repositoryConnection.d.ts +0 -4
  318. package/dist/core/database/transaction.d.ts +0 -23
  319. package/dist/core/database/transactionControl.d.ts +0 -6
  320. package/dist/core/events/deferredModelEvents.d.ts +0 -7
  321. package/dist/core/facades/index.d.ts +0 -10
  322. package/dist/core/runtime/applicationRegistry.d.ts +0 -18
  323. package/dist/entries/database/bindConnection.js +0 -1
  324. package/dist/entries/database/boundConnection.js +0 -1
  325. package/dist/entries/database/defaultConnection.js +0 -1
  326. package/dist/entries/database/namedConnections.js +0 -1
  327. package/dist/entries/database/repositoryConnection.js +0 -1
  328. package/dist/entries/database/transaction.js +0 -1
  329. package/dist/entries/facades.js +0 -711
  330. package/dist/entries/runtime/applicationRegistry.js +0 -1
@@ -0,0 +1,2082 @@
1
+ // @bun
2
+ // ../../src/core/database/bindings.ts
3
+ import { CORE_EXECUTION_CONTEXT_TOKEN } from "@getstrata/core/contracts/executionContext";
4
+ import { CORE_EXECUTION_OPERATIONS_TOKEN } from "@getstrata/core/contracts/executionOperations";
5
+ import { CORE_EXECUTION_OWNERSHIP_TOKEN } from "@getstrata/core/contracts/executionOwnership";
6
+ import {
7
+ resourceService,
8
+ service
9
+ } from "@getstrata/core/contracts/services";
10
+ import { assertServiceToken, createServiceToken } from "@getstrata/core/contracts/token";
11
+ import { PersistenceError as PersistenceError3 } from "@getstrata/core/database/errors";
12
+ import { DATABASE_MANAGER_TOKEN, DATABASE_SESSION_TOKEN } from "@getstrata/core/database/tokens";
13
+ import { createDatabaseOwnership, DATABASE_OWNERSHIP_TOKEN } from "#strata-orm-internal";
14
+
15
+ // ../../src/core/config/configSnapshot.ts
16
+ function copyApplicationConfig(value, ancestors = new Set) {
17
+ if (value === null || typeof value === "string" || typeof value === "boolean")
18
+ return value;
19
+ if (typeof value === "number" && Number.isFinite(value))
20
+ return value;
21
+ if (typeof value !== "object" || ancestors.has(value)) {
22
+ throw new TypeError("Application config must contain acyclic plain data.");
23
+ }
24
+ const array = Array.isArray(value);
25
+ const prototype = Object.getPrototypeOf(value);
26
+ if (prototype !== (array ? Array.prototype : Object.prototype) && !(prototype === null && !array)) {
27
+ throw new TypeError("Application config must contain only plain objects and arrays.");
28
+ }
29
+ if (Object.getOwnPropertySymbols(value).length > 0) {
30
+ throw new TypeError("Application config cannot contain symbol keys.");
31
+ }
32
+ const descriptors = Object.getOwnPropertyDescriptors(value);
33
+ for (const [key, descriptor] of Object.entries(descriptors)) {
34
+ if (!(array && key === "length") && (!descriptor.enumerable || !("value" in descriptor))) {
35
+ throw new TypeError("Application config cannot contain accessors or hidden properties.");
36
+ }
37
+ }
38
+ ancestors.add(value);
39
+ try {
40
+ if (array) {
41
+ const length = descriptors.length.value;
42
+ if (Object.keys(descriptors).length !== length + 1) {
43
+ throw new TypeError("Application config arrays must be dense and have no extra properties.");
44
+ }
45
+ const result = [];
46
+ for (let index = 0;index < length; index++) {
47
+ const descriptor = descriptors[String(index)];
48
+ if (!descriptor)
49
+ throw new TypeError("Application config arrays must be dense.");
50
+ result.push(copyApplicationConfig(descriptor.value, ancestors));
51
+ }
52
+ return Object.freeze(result);
53
+ }
54
+ const result = {};
55
+ for (const [key, descriptor] of Object.entries(descriptors)) {
56
+ Object.defineProperty(result, key, {
57
+ value: copyApplicationConfig(descriptor.value, ancestors),
58
+ enumerable: true
59
+ });
60
+ }
61
+ return Object.freeze(result);
62
+ } finally {
63
+ ancestors.delete(value);
64
+ }
65
+ }
66
+
67
+ // ../../src/core/database/manager.ts
68
+ import { PersistenceError } from "@getstrata/core/database/errors";
69
+
70
+ class DatabaseManager {
71
+ defaultConnection;
72
+ ownership;
73
+ pools;
74
+ constructor(defaultConnection, connections, ownership) {
75
+ this.defaultConnection = defaultConnection;
76
+ this.ownership = ownership;
77
+ const pools = new Map(connections);
78
+ if (!pools.has(defaultConnection))
79
+ throw new PersistenceError("DATABASE_CONFIG_INVALID");
80
+ if (new Set(pools.values()).size !== pools.size)
81
+ throw new PersistenceError("DATABASE_CONFIG_INVALID");
82
+ this.pools = pools;
83
+ Object.freeze(this);
84
+ }
85
+ configuredPool(pool) {
86
+ for (const [name, configured] of this.pools)
87
+ if (configured === pool) {
88
+ const identity = this.ownership.connections[name];
89
+ if (identity)
90
+ return identity;
91
+ }
92
+ throw new PersistenceError("DATABASE_CONFIG_INVALID");
93
+ }
94
+ connection(name = this.defaultConnection) {
95
+ const pool = this.pools.get(name);
96
+ if (!pool)
97
+ throw new PersistenceError("DATABASE_CONNECTION_UNKNOWN");
98
+ return pool;
99
+ }
100
+ }
101
+
102
+ // ../../src/core/database/modelRegistry.ts
103
+ import { assertServicePayload } from "@getstrata/core/contracts/services";
104
+ import { serviceTokenKey } from "@getstrata/core/contracts/token";
105
+ import {
106
+ assertDefinition,
107
+ assertRepositoryEffectsDeclaration
108
+ } from "@getstrata/core/database/definitions";
109
+ import {
110
+ attachBindingPorts,
111
+ attachSessionIdentity,
112
+ createMutationPorts
113
+ } from "#strata-orm-internal";
114
+ import {
115
+ BaseRepository,
116
+ createBoundModel,
117
+ getModelBinding,
118
+ getRepositoryBinding,
119
+ Model
120
+ } from "#strata-orm-runtime";
121
+
122
+ // ../../src/core/events/eventBusClass.ts
123
+ class EventBus {
124
+ constructor() {}
125
+ transactionalListeners = new Map;
126
+ listenTransactional(event, listener) {
127
+ const handlers = this.transactionalListeners.get(event) ?? new Set;
128
+ handlers.add(listener);
129
+ this.transactionalListeners.set(event, handlers);
130
+ return () => {
131
+ handlers.delete(listener);
132
+ if (!handlers.size)
133
+ this.transactionalListeners.delete(event);
134
+ };
135
+ }
136
+ hasTransactionalListeners(event) {
137
+ return (this.transactionalListeners.get(event)?.size ?? 0) > 0;
138
+ }
139
+ async dispatchTransactional(event, payload) {
140
+ for (const listener of this.transactionalListeners.get(event) ?? [])
141
+ await listener(payload);
142
+ }
143
+ listeners = new Map;
144
+ on(event, listener) {
145
+ return this.listen(event, listener);
146
+ }
147
+ listen(event, listener) {
148
+ const handlers = this.listeners.get(event) ?? new Set;
149
+ handlers.add(listener);
150
+ this.listeners.set(event, handlers);
151
+ return () => {
152
+ handlers.delete(listener);
153
+ if (handlers.size === 0) {
154
+ this.listeners.delete(event);
155
+ }
156
+ };
157
+ }
158
+ async emit(event, payload) {
159
+ await this.dispatch(event, payload);
160
+ }
161
+ async dispatch(event, payload) {
162
+ const handlers = this.listeners.get(event);
163
+ if (!handlers || handlers.size === 0) {
164
+ return;
165
+ }
166
+ for (const handler of handlers) {
167
+ await handler(payload);
168
+ }
169
+ }
170
+ }
171
+
172
+ // ../../src/core/tenant/scopedDatabasePolicy.ts
173
+ import { assertSameSessionSelection } from "#strata-orm-internal";
174
+ function assertBypassIdentifier(identifier) {
175
+ if (typeof identifier === "number" ? Number.isSafeInteger(identifier) && identifier > 0 : typeof identifier === "string" && identifier.trim().length > 0)
176
+ return;
177
+ throw new TypeError("RLS bypass requires a caller-supplied identifier that pins the row.");
178
+ }
179
+ function createScopedPolicy(ownership, context, selectedRoot) {
180
+ return Object.freeze({
181
+ run: (selected, policy, work) => {
182
+ assertSameSessionSelection(selectedRoot, selected);
183
+ if (!policy || typeof policy !== "object" || !["tenant", "identifier", "bypass"].includes(policy.kind))
184
+ throw new TypeError("Invalid established database policy.");
185
+ if (selected.dialect.driver !== "pgsql") {
186
+ throw new TypeError("RLS tenant scope requires PostgreSQL.");
187
+ }
188
+ if (typeof work !== "function")
189
+ throw new TypeError("Policy callback must be a function.");
190
+ if (policy.kind === "tenant") {
191
+ if (typeof policy.tenantId !== "number")
192
+ throw new TypeError("Tenant identity must be a positive integer.");
193
+ assertBypassIdentifier(policy.tenantId);
194
+ if (!context.tenant || context.tenant.id !== policy.tenantId)
195
+ throw new Error("Established tenant identity mismatch.");
196
+ }
197
+ if (policy.kind === "identifier")
198
+ assertBypassIdentifier(policy.identifier);
199
+ const applied = Object.freeze(policy.kind === "tenant" ? { kind: "tenant", tenantId: policy.tenantId } : policy.kind === "identifier" ? { kind: "identifier", identifier: String(policy.identifier).trim() } : { kind: "bypass" });
200
+ return selected.transaction(async (child) => {
201
+ const [previous] = await child.execute({
202
+ text: `SELECT current_setting('app.tenant_id', true) AS tenant_id,
203
+ current_setting('app.bypass_rls', true) AS bypass_rls,
204
+ current_setting('app.bypass_identifier', true) AS bypass_identifier`,
205
+ params: []
206
+ });
207
+ if (applied.kind === "tenant") {
208
+ await child.execute({
209
+ text: `SELECT set_config('app.tenant_id', $1, true), set_config('app.bypass_rls', $2, true)`,
210
+ params: [String(applied.tenantId), "false"]
211
+ });
212
+ } else if (applied.kind === "bypass") {
213
+ await child.execute({
214
+ text: `SELECT set_config('app.bypass_rls', $1, true)`,
215
+ params: ["true"]
216
+ });
217
+ } else {
218
+ await child.execute({
219
+ text: `SELECT set_config('app.bypass_identifier', $1, true)`,
220
+ params: [String(applied.identifier).trim()]
221
+ });
222
+ }
223
+ const observation = await ownership.joined(() => work(child));
224
+ if (!observation.body.ok)
225
+ throw observation.body.error;
226
+ if (observation.strictFailed || observation.retained)
227
+ return observation.body.value;
228
+ await child.execute({
229
+ text: `SELECT set_config('app.tenant_id', $1, true),
230
+ set_config('app.bypass_rls', $2, true), set_config('app.bypass_identifier', $3, true)`,
231
+ params: [
232
+ previous?.tenant_id ?? "",
233
+ previous?.bypass_rls ?? "",
234
+ previous?.bypass_identifier ?? ""
235
+ ]
236
+ });
237
+ return observation.body.value;
238
+ });
239
+ }
240
+ });
241
+ }
242
+
243
+ // ../../src/core/database/modelRegistry.ts
244
+ function definitionArray(values) {
245
+ if (!Array.isArray(values))
246
+ throw new TypeError("Database definitions must be arrays.");
247
+ const copied = [];
248
+ for (let index = 0;index < values.length; index++) {
249
+ const descriptor = Object.getOwnPropertyDescriptor(values, String(index));
250
+ if (!descriptor || !("value" in descriptor))
251
+ throw new TypeError("Definition array accessors and holes are unsupported.");
252
+ copied.push(descriptor.value);
253
+ }
254
+ return Object.freeze(copied);
255
+ }
256
+ function snapshotRegistry(repositories = [], models = [], repositoryEffects = []) {
257
+ repositories = definitionArray(repositories);
258
+ models = definitionArray(models);
259
+ repositoryEffects = definitionArray(repositoryEffects);
260
+ const repos = new Set;
261
+ const repoNames = new Set;
262
+ const names = new Set;
263
+ const definitions = new Set;
264
+ const dependencies = [];
265
+ const add = (token) => {
266
+ if (!dependencies.some((existing) => serviceTokenKey(existing) === serviceTokenKey(token)))
267
+ dependencies.push(token);
268
+ };
269
+ for (const definition of repositories) {
270
+ assertDefinition(definition, "repository");
271
+ if (repos.has(definition) || repoNames.has(definition.name))
272
+ throw new TypeError("Duplicate repository definition.");
273
+ repos.add(definition);
274
+ repoNames.add(definition.name);
275
+ definition.dependencies.forEach(add);
276
+ for (const effect of definition.effects) {
277
+ if (effect.transactional)
278
+ add(effect.transactional);
279
+ if (effect.afterCommit)
280
+ add(effect.afterCommit);
281
+ }
282
+ }
283
+ for (const declaration of repositoryEffects) {
284
+ assertRepositoryEffectsDeclaration(declaration);
285
+ assertDefinition(declaration.definition, "repository");
286
+ if (!repos.has(declaration.definition))
287
+ throw new TypeError("Effect repository is not registered.");
288
+ for (const effect of declaration.effects) {
289
+ if (effect.transactional)
290
+ add(effect.transactional);
291
+ if (effect.afterCommit)
292
+ add(effect.afterCommit);
293
+ }
294
+ }
295
+ for (const definition of models) {
296
+ assertDefinition(definition, "model");
297
+ if (definitions.has(definition) || !repos.has(definition.repository))
298
+ throw new TypeError("Duplicate model or unregistered repository.");
299
+ definitions.add(definition);
300
+ for (const name of [definition.name, ...definition.aliases]) {
301
+ if (names.has(name))
302
+ throw new TypeError("Duplicate model alias.");
303
+ names.add(name);
304
+ }
305
+ const columns = definition.repository.table.columns;
306
+ for (const key of ["fillable", "guarded"]) {
307
+ const values = definition.attributes[key];
308
+ if (Array.isArray(values) && values.some((value) => !columns.includes(value)))
309
+ throw new TypeError("Unknown model attribute column.");
310
+ }
311
+ for (const key of Object.keys(definition.attributes.casts ?? {}))
312
+ if (!columns.includes(key))
313
+ throw new TypeError("Unknown cast column.");
314
+ definition.dependencies.forEach(add);
315
+ definition.observers.forEach(add);
316
+ }
317
+ return Object.freeze({
318
+ repositories: Object.freeze([...repositories]),
319
+ models: Object.freeze([...models]),
320
+ dependencies: Object.freeze(dependencies),
321
+ repositoryEffects
322
+ });
323
+ }
324
+ function prepareRegistry(snapshot, values, app) {
325
+ const supplied = new Map(snapshot.dependencies.map((token, index) => [serviceTokenKey(token), values[index]]));
326
+ const resolve = (token) => supplied.get(serviceTokenKey(token));
327
+ const repositories = new Map;
328
+ for (const definition of snapshot.repositories) {
329
+ const bus = new EventBus;
330
+ for (const effect of [
331
+ ...definition.effects,
332
+ ...snapshot.repositoryEffects.filter((item) => item.definition === definition).flatMap((item) => item.effects)
333
+ ]) {
334
+ if (effect.transactional) {
335
+ const listener = resolve(effect.transactional);
336
+ if (typeof listener !== "function")
337
+ throw new TypeError("Transactional listener must be a function.");
338
+ bus.listenTransactional(effect.action, listener);
339
+ }
340
+ if (effect.afterCommit) {
341
+ const listener = resolve(effect.afterCommit);
342
+ if (typeof listener !== "function")
343
+ throw new TypeError("After-commit listener must be a function.");
344
+ bus.listen(effect.action, async (payload) => {
345
+ const p = payload;
346
+ await listener(p.row, p.context);
347
+ });
348
+ }
349
+ }
350
+ repositories.set(definition, Object.freeze({
351
+ definition,
352
+ dependencies: Object.freeze(definition.dependencies.map(resolve)),
353
+ bus
354
+ }));
355
+ }
356
+ const models = new Map;
357
+ const names = new Map;
358
+ for (const definition of snapshot.models) {
359
+ models.set(definition, Object.freeze({
360
+ definition,
361
+ dependencies: Object.freeze(definition.dependencies.map(resolve)),
362
+ observers: Object.freeze(definition.observers.map(resolve))
363
+ }));
364
+ for (const name of [definition.name, ...definition.aliases])
365
+ names.set(name, definition);
366
+ }
367
+ return Object.freeze({ app, repositories, models, names });
368
+ }
369
+ function createBoundRegistryFactory(prepared, context, ownership, configuredPool) {
370
+ const attachments = new WeakMap;
371
+ const execution = Object.freeze({});
372
+ return {
373
+ attach(session, authority) {
374
+ if (attachments.has(session))
375
+ throw new TypeError("Session already attached.");
376
+ const repositories = new Map;
377
+ const models = new Map;
378
+ const mutation = createMutationPorts(ownership, authority.assertActive);
379
+ const tenant = context.tenant;
380
+ const registry = {
381
+ repository(definition) {
382
+ authority.assertActive();
383
+ assertDefinition(definition, "repository");
384
+ const erased = definition;
385
+ const template = prepared.repositories.get(erased);
386
+ if (!template)
387
+ throw new TypeError("Repository is not registered in this application.");
388
+ const cached = repositories.get(erased);
389
+ if (cached)
390
+ return cached;
391
+ const binding = makeBinding(erased);
392
+ const result = template.definition.create(binding, ...template.dependencies);
393
+ assertServicePayload(result);
394
+ if (!(result instanceof BaseRepository) || getRepositoryBinding(result) !== binding)
395
+ throw new TypeError("Repository constructor returned the wrong binding.");
396
+ repositories.set(erased, result);
397
+ return result;
398
+ },
399
+ model(definition) {
400
+ authority.assertActive();
401
+ assertDefinition(definition, "model");
402
+ const erased = definition;
403
+ const template = prepared.models.get(erased);
404
+ if (!template)
405
+ throw new TypeError("Model is not registered in this application.");
406
+ const cached = models.get(erased);
407
+ if (cached)
408
+ return cached;
409
+ const binding = makeBinding(erased.repository, template);
410
+ const facade = createBoundModel(binding);
411
+ models.set(erased, facade);
412
+ return facade;
413
+ }
414
+ };
415
+ function makeBinding(definition, model) {
416
+ const template = prepared.repositories.get(definition);
417
+ if (!template)
418
+ throw new TypeError("Repository not registered.");
419
+ const binding = {
420
+ session,
421
+ table: definition.table,
422
+ dialect: authority.pool.dialect,
423
+ capabilities: authority.pool.capabilities,
424
+ run: authority.run,
425
+ ...model ? {
426
+ definition: model.definition,
427
+ repository: registry.repository(definition)
428
+ } : {}
429
+ };
430
+ const ports = {
431
+ app: prepared.app,
432
+ pool: authority.pool,
433
+ branch: authority.branch,
434
+ tenant,
435
+ definition,
436
+ hooks: definition.hooks,
437
+ assertActive: authority.assertActive,
438
+ repository: registry.repository,
439
+ model: (value) => {
440
+ const def = typeof value === "string" ? prepared.names.get(value) : value;
441
+ if (!def)
442
+ throw new TypeError("Unknown related model.");
443
+ return registry.model(def);
444
+ },
445
+ reselect: (child) => child.repository(definition),
446
+ assertMutation: (action) => {
447
+ authority.assertActive();
448
+ if (template.bus.hasTransactionalListeners(action) && !authority.transactional)
449
+ throw new TypeError("Transactional listeners require an explicit transaction.");
450
+ },
451
+ mutation: (action, work) => {
452
+ ports.assertMutation(action);
453
+ if (!template.bus.hasTransactionalListeners(action))
454
+ return authority.run(() => work(registry.repository(definition)));
455
+ return session.transaction((child) => work(child.repository(definition)));
456
+ },
457
+ publish: async (action, row) => {
458
+ authority.assertActive();
459
+ const copied = Object.freeze({ ...row });
460
+ if (template.bus.hasTransactionalListeners(action)) {
461
+ await template.bus.dispatchTransactional(action, Object.freeze({
462
+ session,
463
+ definition,
464
+ action,
465
+ row: copied
466
+ }));
467
+ }
468
+ const after = () => {
469
+ const database = authority.root();
470
+ const publicationContext = Object.freeze({
471
+ database,
472
+ execution: context,
473
+ policy: createScopedPolicy(ownership, context, database)
474
+ });
475
+ return template.bus.dispatch(action, { row: copied, context: publicationContext });
476
+ };
477
+ if (authority.transactional)
478
+ session.afterCommit(after);
479
+ else
480
+ await after();
481
+ },
482
+ registerRestore: authority.registerRestore,
483
+ mutate: (entity, work) => mutation.mutate(entity, authority.run, work),
484
+ assertEditable: mutation.assertEditable,
485
+ assertBindable: mutation.assertBindable,
486
+ dehydrate: model?.definition.attributes.dehydrate ? (values) => model.definition.attributes.dehydrate(values, ...model.dependencies) : undefined,
487
+ observers: model?.observers ?? [],
488
+ scopes: model ? model.definition.scopes.map((scope) => (query) => scope(query, ...model.dependencies)) : [],
489
+ modelDefinition: model?.definition,
490
+ construct: model ? (state, source) => {
491
+ authority.assertActive();
492
+ const result = model.definition.construct(state, binding, source, ...model.dependencies);
493
+ assertServicePayload(result);
494
+ if (!(result instanceof Model) || getModelBinding(result) !== binding)
495
+ throw new TypeError("Model constructor returned the wrong binding.");
496
+ return result;
497
+ } : undefined
498
+ };
499
+ return attachBindingPorts(binding, ports);
500
+ }
501
+ attachSessionIdentity(session, {
502
+ app: prepared.app,
503
+ execution,
504
+ pool: authority.pool,
505
+ configuredPool: configuredPool(authority.pool),
506
+ transactional: authority.transactional,
507
+ tenant: context.tenant,
508
+ signal: context.signal,
509
+ assertActive: authority.assertActive,
510
+ run: authority.run
511
+ });
512
+ attachments.set(session, registry);
513
+ return registry;
514
+ }
515
+ };
516
+ }
517
+
518
+ // ../../src/core/runtime/optionalPeer.ts
519
+ function missingOptionalPeer(packageName, reason, error) {
520
+ return new Error(`Install ${packageName} ${reason} (\`bun add ${packageName}\`).`, {
521
+ cause: error
522
+ });
523
+ }
524
+
525
+ // ../../src/core/database/mysqlNative.ts
526
+ var MYSQL_SESSION_UTC = "SET time_zone = '+00:00'";
527
+ var mysqlModule;
528
+ var mysqlPending;
529
+ var importMysql = defaultImportMysql;
530
+ async function defaultImportMysql() {
531
+ return import("mysql2/promise");
532
+ }
533
+ function mysqlApi(mod) {
534
+ if (typeof mod.createPool === "function") {
535
+ return mod;
536
+ }
537
+ const withDefault = mod;
538
+ if (typeof withDefault.default?.createPool === "function") {
539
+ return withDefault.default;
540
+ }
541
+ throw new Error("mysql2/promise did not export createPool.");
542
+ }
543
+ async function loadMysql() {
544
+ if (mysqlModule) {
545
+ return mysqlModule;
546
+ }
547
+ if (!mysqlPending) {
548
+ mysqlPending = (async () => {
549
+ let mod;
550
+ try {
551
+ mod = await importMysql();
552
+ } catch (error) {
553
+ mysqlPending = undefined;
554
+ throw missingOptionalPeer("mysql2", "to open a MySQL connection", error);
555
+ }
556
+ try {
557
+ mysqlModule = mysqlApi(mod);
558
+ return mysqlModule;
559
+ } catch (error) {
560
+ mysqlPending = undefined;
561
+ throw error;
562
+ }
563
+ })();
564
+ }
565
+ return mysqlPending;
566
+ }
567
+ function rowsFromResult(result) {
568
+ if (Array.isArray(result)) {
569
+ return result;
570
+ }
571
+ if (result && typeof result === "object") {
572
+ return [result];
573
+ }
574
+ return [];
575
+ }
576
+ async function executeMysql(target, query, params) {
577
+ const [result] = params.length === 0 && target.query ? await target.query(query) : await target.execute(query, [...params]);
578
+ return rowsFromResult(result);
579
+ }
580
+ function pinSessionToUtc(connection) {
581
+ connection.query(MYSQL_SESSION_UTC, (error) => {
582
+ if (error) {
583
+ console.warn("[mysql] Could not set the session time zone to UTC; DATETIME comparisons may drift.");
584
+ }
585
+ });
586
+ }
587
+ function createPoolFromModule(mysql, url, max) {
588
+ const pool = mysql.createPool({
589
+ uri: url,
590
+ timezone: "Z",
591
+ ...max === undefined ? {} : { connectionLimit: max }
592
+ });
593
+ pool.on("connection", (connection) => {
594
+ pinSessionToUtc(connection);
595
+ });
596
+ return pool;
597
+ }
598
+ async function createMysqlPool(url, max) {
599
+ return createPoolFromModule(await loadMysql(), url, max);
600
+ }
601
+
602
+ // ../../src/core/database/nativeTransactions.ts
603
+ var failure = (error) => Object.freeze({ error });
604
+ function nativeTransaction(control) {
605
+ let state = "idle";
606
+ let sequence = 0;
607
+ let running = false;
608
+ const knownState = () => control.state?.() ?? "unknown";
609
+ async function run(work, savepoint) {
610
+ const phases = [];
611
+ let stage = Object.freeze({ kind: "callback-not-entered" });
612
+ let terminalFailure = null;
613
+ let data = "not-started";
614
+ let open = false;
615
+ let childActive = false;
616
+ const phase = async (name, sql) => {
617
+ try {
618
+ const reply = await control.control(sql);
619
+ phases.push(Object.freeze({ phase: name, acknowledgement: "confirmed-reply", failure: null }));
620
+ return reply;
621
+ } catch (error) {
622
+ const proof = knownState();
623
+ phases.push(Object.freeze({
624
+ phase: name,
625
+ acknowledgement: name === "commit" && proof === "transaction-active" || name === "begin" && proof === "idle" ? "proven-not-applied" : "unknown",
626
+ failure: failure(error)
627
+ }));
628
+ state = proof;
629
+ throw error;
630
+ }
631
+ };
632
+ const result = () => Object.freeze({
633
+ data,
634
+ nativeState: state,
635
+ stage,
636
+ phases: Object.freeze([...phases]),
637
+ failure: terminalFailure
638
+ });
639
+ try {
640
+ await phase(savepoint ? "savepoint" : "begin", savepoint ? `SAVEPOINT ${savepoint}` : control.beginSql ?? "BEGIN");
641
+ state = "transaction-active";
642
+ open = true;
643
+ } catch (error) {
644
+ terminalFailure = failure(error);
645
+ data = state === "idle" && !savepoint ? "not-started" : "unknown";
646
+ return result();
647
+ }
648
+ const transaction = Object.freeze({
649
+ execute(statement) {
650
+ if (!open || childActive)
651
+ return Promise.reject(new Error("Native transaction branch is not active."));
652
+ return control.execute(statement);
653
+ },
654
+ async savepoint(callback) {
655
+ if (!open || childActive)
656
+ throw new Error("Native transaction branch is not active.");
657
+ childActive = true;
658
+ try {
659
+ return await run(callback, `strata_sp_${++sequence}`);
660
+ } finally {
661
+ childActive = false;
662
+ }
663
+ }
664
+ });
665
+ stage = Object.freeze({ kind: "callback-running" });
666
+ try {
667
+ const decision = await work(transaction);
668
+ if (!decision || decision.finish !== "commit" && decision.finish !== "rollback")
669
+ throw new TypeError("Invalid native transaction decision.");
670
+ stage = Object.freeze({
671
+ kind: "decided",
672
+ decision: Object.freeze({ finish: decision.finish, result: decision.result })
673
+ });
674
+ } catch (error) {
675
+ stage = Object.freeze({ kind: "callback-failed", error });
676
+ } finally {
677
+ open = false;
678
+ }
679
+ const rollback = async () => {
680
+ if (savepoint) {
681
+ await phase("rollback-to", `ROLLBACK TO SAVEPOINT ${savepoint}`);
682
+ await phase("release-savepoint", `RELEASE SAVEPOINT ${savepoint}`);
683
+ state = "transaction-active";
684
+ } else {
685
+ await phase("rollback", "ROLLBACK");
686
+ state = "idle";
687
+ }
688
+ };
689
+ if (stage.kind === "decided" && stage.decision.finish === "commit") {
690
+ try {
691
+ const reply = await phase(savepoint ? "release-savepoint" : "commit", savepoint ? `RELEASE SAVEPOINT ${savepoint}` : "COMMIT");
692
+ data = savepoint ? "released" : reply.command === "ROLLBACK" ? "rolled-back" : "committed";
693
+ state = savepoint ? "transaction-active" : "idle";
694
+ } catch (error) {
695
+ terminalFailure = failure(error);
696
+ const commitNotApplied = !savepoint && state === "transaction-active" && control.state !== undefined;
697
+ data = "unknown";
698
+ try {
699
+ await rollback();
700
+ if (savepoint || commitNotApplied)
701
+ data = "rolled-back";
702
+ } catch {}
703
+ }
704
+ } else {
705
+ try {
706
+ await rollback();
707
+ data = "rolled-back";
708
+ } catch (error) {
709
+ terminalFailure = failure(error);
710
+ data = "unknown";
711
+ }
712
+ }
713
+ return result();
714
+ }
715
+ return {
716
+ get state() {
717
+ return state;
718
+ },
719
+ async begin(work) {
720
+ if (running)
721
+ throw new Error("Native pin already has an active transaction.");
722
+ running = true;
723
+ try {
724
+ return await run(work);
725
+ } finally {
726
+ running = false;
727
+ }
728
+ }
729
+ };
730
+ }
731
+
732
+ // ../../src/core/database/sqlDialects.ts
733
+ function assertSafeIdentifier(identifier) {
734
+ if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
735
+ throw new Error(`Invalid SQL identifier: ${identifier}`);
736
+ }
737
+ return identifier;
738
+ }
739
+ function quoteIdentifierFor(dialect, column) {
740
+ return dialect.quoteIdentifier(column);
741
+ }
742
+ var postgresDialect = Object.freeze({
743
+ driver: "pgsql",
744
+ placeholder(index) {
745
+ return `$${index}`;
746
+ },
747
+ quoteIdentifier(identifier) {
748
+ return `"${assertSafeIdentifier(identifier)}"`;
749
+ },
750
+ nowExpression() {
751
+ return "NOW()";
752
+ },
753
+ epochMillisecondsExpression() {
754
+ return "CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)";
755
+ },
756
+ rowLockClause(skipLocked = false) {
757
+ return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
758
+ },
759
+ timestampValue(value) {
760
+ return value.toISOString();
761
+ },
762
+ returningClause(columns) {
763
+ return ` RETURNING ${columns}`;
764
+ },
765
+ ilikeOperator() {
766
+ return "ILIKE";
767
+ },
768
+ nullsLastSuffix() {
769
+ return " NULLS LAST";
770
+ },
771
+ castToText(expression) {
772
+ return `${expression}::text`;
773
+ },
774
+ upsertSuffix(conflictColumns, updateColumns) {
775
+ const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
776
+ if (updateColumns.length === 0) {
777
+ return ` ON CONFLICT (${target}) DO NOTHING`;
778
+ }
779
+ const assignments = updateColumns.map((column) => {
780
+ const quoted = quoteIdentifierFor(this, column);
781
+ return `${quoted} = excluded.${quoted}`;
782
+ }).join(", ");
783
+ return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
784
+ }
785
+ });
786
+ var mysqlDialect = Object.freeze({
787
+ driver: "mysql",
788
+ placeholder() {
789
+ return "?";
790
+ },
791
+ quoteIdentifier(identifier) {
792
+ return `\`${assertSafeIdentifier(identifier)}\``;
793
+ },
794
+ nowExpression() {
795
+ return "CURRENT_TIMESTAMP";
796
+ },
797
+ epochMillisecondsExpression() {
798
+ return "CAST(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000 AS UNSIGNED)";
799
+ },
800
+ rowLockClause(skipLocked = false) {
801
+ return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
802
+ },
803
+ timestampValue(value) {
804
+ return value.toISOString().slice(0, 19).replace("T", " ");
805
+ },
806
+ returningClause() {
807
+ return "";
808
+ },
809
+ ilikeOperator() {
810
+ return "LIKE";
811
+ },
812
+ nullsLastSuffix() {
813
+ return "";
814
+ },
815
+ castToText(expression) {
816
+ return `CAST(${expression} AS CHAR)`;
817
+ },
818
+ upsertSuffix(conflictColumns, updateColumns) {
819
+ if (updateColumns.length === 0) {
820
+ const anchor = quoteIdentifierFor(this, conflictColumns[0] ?? "");
821
+ return ` ON DUPLICATE KEY UPDATE ${anchor} = ${anchor}`;
822
+ }
823
+ const assignments = updateColumns.map((column) => {
824
+ const quoted = quoteIdentifierFor(this, column);
825
+ return `${quoted} = VALUES(${quoted})`;
826
+ }).join(", ");
827
+ return ` ON DUPLICATE KEY UPDATE ${assignments}`;
828
+ }
829
+ });
830
+ var sqliteDialect = Object.freeze({
831
+ driver: "sqlite",
832
+ placeholder() {
833
+ return "?";
834
+ },
835
+ quoteIdentifier(identifier) {
836
+ return `"${assertSafeIdentifier(identifier)}"`;
837
+ },
838
+ nowExpression() {
839
+ return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
840
+ },
841
+ epochMillisecondsExpression() {
842
+ return "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
843
+ },
844
+ rowLockClause() {
845
+ return "";
846
+ },
847
+ timestampValue(value) {
848
+ return value.toISOString();
849
+ },
850
+ returningClause(columns) {
851
+ return ` RETURNING ${columns}`;
852
+ },
853
+ ilikeOperator() {
854
+ return "LIKE";
855
+ },
856
+ nullsLastSuffix() {
857
+ return "";
858
+ },
859
+ castToText(expression) {
860
+ return `CAST(${expression} AS TEXT)`;
861
+ },
862
+ upsertSuffix(conflictColumns, updateColumns) {
863
+ const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
864
+ if (updateColumns.length === 0) {
865
+ return ` ON CONFLICT (${target}) DO NOTHING`;
866
+ }
867
+ const assignments = updateColumns.map((column) => {
868
+ const quoted = quoteIdentifierFor(this, column);
869
+ return `${quoted} = excluded.${quoted}`;
870
+ }).join(", ");
871
+ return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
872
+ }
873
+ });
874
+ var dialects = Object.freeze({
875
+ pgsql: postgresDialect,
876
+ mysql: mysqlDialect,
877
+ sqlite: sqliteDialect
878
+ });
879
+ function dialectFor(driver) {
880
+ if (!Object.hasOwn(dialects, driver))
881
+ throw new TypeError("Unsupported SQL driver.");
882
+ return dialects[driver];
883
+ }
884
+
885
+ // ../../src/core/database/rawMysql.ts
886
+ function destroyMysqlConnection(connection) {
887
+ const stream = connection.connection?.stream;
888
+ if (!stream || typeof stream.once !== "function" || typeof stream.removeListener !== "function") {
889
+ try {
890
+ connection.destroy();
891
+ } catch (error) {
892
+ return Promise.resolve({ ok: false, error, ownership: "unknown" });
893
+ }
894
+ return Promise.resolve({
895
+ ok: false,
896
+ error: new Error("MySQL physical socket close acknowledgement is unavailable."),
897
+ ownership: "unknown"
898
+ });
899
+ }
900
+ return new Promise((resolve) => {
901
+ let invoking = true;
902
+ let closed = stream.closed === true;
903
+ const acknowledge = () => {
904
+ try {
905
+ stream.removeListener("close", onClose);
906
+ resolve(Object.freeze({ ok: true }));
907
+ } catch (error) {
908
+ resolve(Object.freeze({ ok: false, error, ownership: "unknown" }));
909
+ }
910
+ };
911
+ const onClose = () => {
912
+ closed = true;
913
+ if (!invoking)
914
+ acknowledge();
915
+ };
916
+ try {
917
+ if (!closed)
918
+ stream.once("close", onClose);
919
+ connection.destroy();
920
+ invoking = false;
921
+ if (closed || stream.closed === true)
922
+ acknowledge();
923
+ } catch (error) {
924
+ invoking = false;
925
+ try {
926
+ stream.removeListener("close", onClose);
927
+ } catch (cleanupError) {
928
+ resolve({
929
+ ok: false,
930
+ error: new AggregateError([error, cleanupError], "MySQL disposal and listener cleanup failed."),
931
+ ownership: "unknown"
932
+ });
933
+ return;
934
+ }
935
+ resolve({ ok: false, error, ownership: "unknown" });
936
+ }
937
+ });
938
+ }
939
+ function createMysqlPin(connection) {
940
+ let disposal;
941
+ let running = false;
942
+ const protocol = nativeTransaction({
943
+ execute: (statement) => executeMysql(connection, statement.text, statement.params),
944
+ async control(sql) {
945
+ if (sql === "BEGIN")
946
+ await connection.beginTransaction();
947
+ else if (sql === "COMMIT")
948
+ await connection.commit();
949
+ else if (sql === "ROLLBACK")
950
+ await connection.rollback();
951
+ else
952
+ await executeMysql(connection, sql, []);
953
+ return {};
954
+ }
955
+ });
956
+ const dispose = (discard) => {
957
+ disposal ??= (async () => {
958
+ if (running || !discard && protocol.state !== "idle")
959
+ return Object.freeze({
960
+ ok: false,
961
+ error: new Error("MySQL native pin is not safely idle."),
962
+ ownership: "retained"
963
+ });
964
+ try {
965
+ if (discard)
966
+ return await destroyMysqlConnection(connection);
967
+ connection.release();
968
+ return Object.freeze({ ok: true });
969
+ } catch (error) {
970
+ return Object.freeze({ ok: false, error, ownership: "unknown" });
971
+ }
972
+ })();
973
+ return disposal;
974
+ };
975
+ return Object.freeze({
976
+ async begin(work) {
977
+ if (disposal || running)
978
+ throw new Error("MySQL pin is no longer available.");
979
+ running = true;
980
+ try {
981
+ return await protocol.begin(work);
982
+ } finally {
983
+ running = false;
984
+ }
985
+ },
986
+ release: () => dispose(false),
987
+ discard: () => dispose(true)
988
+ });
989
+ }
990
+ async function createRawMysqlPool(options) {
991
+ const pool = await createMysqlPool(options.url, options.max);
992
+ let closed = false;
993
+ let retainedCleanup;
994
+ const acquire = async () => {
995
+ if (closed)
996
+ throw new Error("MySQL pool is closed.");
997
+ if (retainedCleanup)
998
+ throw new Error("MySQL pool has unresolved physical cleanup ownership.");
999
+ if (!pool.getConnection)
1000
+ throw new Error("MySQL transactions require a pool with getConnection().");
1001
+ return pool.getConnection();
1002
+ };
1003
+ const initialize = async (connection) => {
1004
+ await executeMysql(connection, "SET time_zone = '+00:00'", []);
1005
+ const rows = await executeMysql(connection, "SELECT @@session.time_zone AS strata_session_timezone", []);
1006
+ if (rows[0]?.strata_session_timezone !== "+00:00")
1007
+ throw new Error("MySQL session UTC initialization was not confirmed.");
1008
+ };
1009
+ return Object.freeze({
1010
+ dialect: dialectFor("mysql"),
1011
+ capabilities: Object.freeze({
1012
+ driver: "mysql",
1013
+ transactions: true,
1014
+ savepoints: true,
1015
+ rowLocks: true,
1016
+ postgresRls: false,
1017
+ cancellableCheckout: false,
1018
+ observableCheckout: false,
1019
+ isolatedDiscard: true
1020
+ }),
1021
+ async execute(statement) {
1022
+ const connection = await acquire();
1023
+ let initialized = false;
1024
+ let queryFailure;
1025
+ let rows = [];
1026
+ try {
1027
+ await initialize(connection);
1028
+ initialized = true;
1029
+ rows = await executeMysql(connection, statement.text, statement.params);
1030
+ } catch (error) {
1031
+ queryFailure = { error };
1032
+ }
1033
+ let acknowledgement;
1034
+ if (!initialized)
1035
+ acknowledgement = await destroyMysqlConnection(connection);
1036
+ else {
1037
+ try {
1038
+ connection.release();
1039
+ acknowledgement = { ok: true };
1040
+ } catch (error) {
1041
+ acknowledgement = { ok: false, error, ownership: "unknown" };
1042
+ }
1043
+ }
1044
+ if (!acknowledgement.ok) {
1045
+ retainedCleanup ??= { error: acknowledgement.error };
1046
+ throw new AggregateError([...queryFailure ? [queryFailure.error] : [], acknowledgement.error], "MySQL query cleanup acknowledgement failed.");
1047
+ }
1048
+ if (queryFailure)
1049
+ throw queryFailure.error;
1050
+ return rows;
1051
+ },
1052
+ async checkout(checkout = {}) {
1053
+ if (checkout.signal !== undefined || checkout.metrics !== undefined)
1054
+ return {
1055
+ ok: false,
1056
+ error: new Error("MySQL checkout does not support acquisition signal or metrics."),
1057
+ disposition: "not-acquired"
1058
+ };
1059
+ let connection;
1060
+ try {
1061
+ connection = await acquire();
1062
+ } catch (error) {
1063
+ return { ok: false, error, disposition: "not-acquired" };
1064
+ }
1065
+ try {
1066
+ await initialize(connection);
1067
+ return { ok: true, value: createMysqlPin(connection) };
1068
+ } catch (error) {
1069
+ const acknowledgement = await destroyMysqlConnection(connection);
1070
+ if (acknowledgement.ok)
1071
+ return { ok: false, error, disposition: "cleaned" };
1072
+ retainedCleanup ??= { error: acknowledgement.error };
1073
+ return { ok: false, error, disposition: "unknown", cleanupErrors: [acknowledgement.error] };
1074
+ }
1075
+ },
1076
+ async close() {
1077
+ if (retainedCleanup)
1078
+ throw retainedCleanup.error;
1079
+ await pool.end();
1080
+ closed = true;
1081
+ }
1082
+ });
1083
+ }
1084
+
1085
+ // ../../src/core/database/rawPostgres.ts
1086
+ import { observeTransactionAcquisition } from "@getstrata/core/database/acquisitionMetrics";
1087
+
1088
+ // ../../src/core/database/postgresNative.ts
1089
+ var {SQL } = globalThis.Bun;
1090
+ function createNativePostgresPool(options) {
1091
+ if (!options.url) {
1092
+ throw new Error("DATABASE_URL is not configured. Set url before creating a Bun SQL pool.");
1093
+ }
1094
+ return new SQL({
1095
+ url: options.url,
1096
+ max: options.max ?? 10,
1097
+ idleTimeout: options.idleTimeout ?? 30,
1098
+ maxLifetime: options.maxLifetime ?? 3600,
1099
+ connectionTimeout: options.connectionTimeout ?? 10
1100
+ });
1101
+ }
1102
+
1103
+ // ../../src/core/database/rawPostgres.ts
1104
+ function postgresPin(connection) {
1105
+ let disposal;
1106
+ let running = false;
1107
+ const protocol = nativeTransaction({
1108
+ execute: async (statement) => await connection.unsafe(statement.text, [...statement.params]),
1109
+ async control(sql) {
1110
+ const reply = await connection.unsafe(sql, []);
1111
+ const expected = sql.startsWith("ROLLBACK") ? ["ROLLBACK"] : sql.startsWith("RELEASE") ? ["RELEASE"] : sql.startsWith("SAVEPOINT") ? ["SAVEPOINT"] : sql === "COMMIT" ? ["COMMIT", "ROLLBACK"] : ["BEGIN"];
1112
+ if (!reply.command || !expected.includes(reply.command))
1113
+ throw new Error("PostgreSQL transaction control acknowledgement was not confirmed.");
1114
+ return { command: reply.command };
1115
+ }
1116
+ });
1117
+ function dispose(discard) {
1118
+ disposal ??= (async () => {
1119
+ if (running || !discard && protocol.state !== "idle")
1120
+ return Object.freeze({
1121
+ ok: false,
1122
+ error: new Error("PostgreSQL native pin is not safely idle."),
1123
+ ownership: "retained"
1124
+ });
1125
+ try {
1126
+ if (discard)
1127
+ await connection.close({ timeout: 0 });
1128
+ else
1129
+ await connection.release();
1130
+ return Object.freeze({ ok: true });
1131
+ } catch (error) {
1132
+ return Object.freeze({ ok: false, error, ownership: "unknown" });
1133
+ }
1134
+ })();
1135
+ return disposal;
1136
+ }
1137
+ return Object.freeze({
1138
+ async begin(work) {
1139
+ if (disposal || running)
1140
+ throw new Error("PostgreSQL pin is no longer available.");
1141
+ running = true;
1142
+ try {
1143
+ return await protocol.begin(work);
1144
+ } finally {
1145
+ running = false;
1146
+ }
1147
+ },
1148
+ release: () => dispose(false),
1149
+ discard: () => dispose(true)
1150
+ });
1151
+ }
1152
+ function createRawPostgresPoolFromNative(pool) {
1153
+ let closed = false;
1154
+ return Object.freeze({
1155
+ dialect: dialectFor("pgsql"),
1156
+ capabilities: Object.freeze({
1157
+ driver: "pgsql",
1158
+ transactions: true,
1159
+ savepoints: true,
1160
+ rowLocks: true,
1161
+ postgresRls: true,
1162
+ cancellableCheckout: true,
1163
+ observableCheckout: true,
1164
+ isolatedDiscard: true
1165
+ }),
1166
+ async execute(statement) {
1167
+ if (closed)
1168
+ throw new Error("PostgreSQL pool is closed.");
1169
+ return await pool.unsafe(statement.text, [...statement.params]);
1170
+ },
1171
+ async checkout(checkout = {}) {
1172
+ if (closed)
1173
+ return {
1174
+ ok: false,
1175
+ error: new Error("PostgreSQL pool is closed."),
1176
+ disposition: "not-acquired"
1177
+ };
1178
+ try {
1179
+ const acquire = () => pool.reserve(checkout.signal === undefined ? undefined : { signal: checkout.signal });
1180
+ const connection = await (checkout.metrics ? observeTransactionAcquisition(checkout.metrics, acquire, checkout.signal) : acquire());
1181
+ return { ok: true, value: postgresPin(connection) };
1182
+ } catch (error) {
1183
+ return { ok: false, error, disposition: "not-acquired" };
1184
+ }
1185
+ },
1186
+ async close() {
1187
+ await pool.close();
1188
+ closed = true;
1189
+ }
1190
+ });
1191
+ }
1192
+ function createRawPostgresPool(options) {
1193
+ return createRawPostgresPoolFromNative(createNativePostgresPool(options));
1194
+ }
1195
+
1196
+ // ../../src/core/database/rawSqlite.ts
1197
+ import { Database } from "bun:sqlite";
1198
+ import { resolve } from "path";
1199
+ function sqliteFilename(filename) {
1200
+ if (!filename.trim())
1201
+ throw new Error("SQLite path is not configured. Pass a filename or :memory:.");
1202
+ return filename === ":memory:" ? filename : resolve(filename);
1203
+ }
1204
+ function isRowReturning(sql) {
1205
+ const upper = sql.replace(/\s+/g, " ").trim().toUpperCase();
1206
+ return upper.includes(" RETURNING ") || upper.startsWith("SELECT") || upper.startsWith("WITH") || upper.startsWith("PRAGMA") || upper.startsWith("EXPLAIN");
1207
+ }
1208
+ function openRawSqlitePool(options) {
1209
+ let filename;
1210
+ try {
1211
+ filename = sqliteFilename(options.filename);
1212
+ } catch (error) {
1213
+ return { ok: false, error, disposition: "not-acquired" };
1214
+ }
1215
+ let db;
1216
+ try {
1217
+ db = new Database(filename, { create: true });
1218
+ } catch (error) {
1219
+ return { ok: false, error, disposition: "unknown" };
1220
+ }
1221
+ try {
1222
+ db.exec("PRAGMA foreign_keys = ON");
1223
+ db.exec("PRAGMA busy_timeout = 5000");
1224
+ if (filename !== ":memory:") {
1225
+ db.exec("PRAGMA journal_mode = WAL");
1226
+ db.exec("PRAGMA synchronous = NORMAL");
1227
+ }
1228
+ } catch (error) {
1229
+ try {
1230
+ db.close();
1231
+ return { ok: false, error, disposition: "cleaned" };
1232
+ } catch (cleanupError) {
1233
+ return { ok: false, error, disposition: "unknown", cleanupErrors: [cleanupError] };
1234
+ }
1235
+ }
1236
+ let tail = Promise.resolve();
1237
+ let pending = 0;
1238
+ let closed = false;
1239
+ let quarantined = false;
1240
+ function check() {
1241
+ if (closed)
1242
+ throw new Error("SQLite connection is closed.");
1243
+ if (quarantined)
1244
+ throw new Error("SQLite connection is quarantined after uncertain native state.");
1245
+ }
1246
+ function execute(statement) {
1247
+ try {
1248
+ check();
1249
+ const query = db.query(statement.text);
1250
+ const params = statement.params.map((value) => value instanceof Date ? value.toISOString() : value);
1251
+ if (isRowReturning(statement.text))
1252
+ return Promise.resolve(query.all(...params));
1253
+ query.run(...params);
1254
+ return Promise.resolve([]);
1255
+ } catch (error) {
1256
+ return Promise.reject(error);
1257
+ }
1258
+ }
1259
+ function enqueue(work) {
1260
+ try {
1261
+ check();
1262
+ } catch (error) {
1263
+ return Promise.reject(error);
1264
+ }
1265
+ pending++;
1266
+ const result = tail.then(() => {
1267
+ check();
1268
+ return work();
1269
+ }).finally(() => {
1270
+ pending--;
1271
+ });
1272
+ tail = result.then(() => {}, () => {});
1273
+ return result;
1274
+ }
1275
+ const pool = Object.freeze({
1276
+ dialect: dialectFor("sqlite"),
1277
+ capabilities: Object.freeze({
1278
+ driver: "sqlite",
1279
+ transactions: true,
1280
+ savepoints: true,
1281
+ rowLocks: false,
1282
+ postgresRls: false,
1283
+ cancellableCheckout: false,
1284
+ observableCheckout: false,
1285
+ isolatedDiscard: false
1286
+ }),
1287
+ execute(statement) {
1288
+ return enqueue(() => execute(statement));
1289
+ },
1290
+ checkout(options = {}) {
1291
+ if (options.signal !== undefined || options.metrics !== undefined)
1292
+ return Promise.resolve({
1293
+ ok: false,
1294
+ error: new Error("SQLite logical checkout does not support acquisition signal or metrics."),
1295
+ disposition: "not-acquired"
1296
+ });
1297
+ return new Promise((publish) => {
1298
+ const reservation = enqueue(async () => {
1299
+ let unlock;
1300
+ const slot = new Promise((done) => {
1301
+ unlock = done;
1302
+ });
1303
+ let disposal;
1304
+ const protocol = nativeTransaction({
1305
+ execute,
1306
+ beginSql: "BEGIN IMMEDIATE",
1307
+ state: () => db.inTransaction ? "transaction-active" : "idle",
1308
+ control: async (sql) => {
1309
+ check();
1310
+ db.exec(sql);
1311
+ return {};
1312
+ }
1313
+ });
1314
+ const pin = Object.freeze({
1315
+ begin: (work) => {
1316
+ if (disposal)
1317
+ return Promise.reject(new Error("SQLite pin is no longer active."));
1318
+ return protocol.begin(work);
1319
+ },
1320
+ async release() {
1321
+ if (disposal)
1322
+ return disposal;
1323
+ if (db.inTransaction || protocol.state !== "idle") {
1324
+ quarantined = true;
1325
+ unlock();
1326
+ disposal = Object.freeze({
1327
+ ok: false,
1328
+ error: new Error("SQLite logical slot is not safely idle."),
1329
+ ownership: "retained"
1330
+ });
1331
+ await reservation;
1332
+ return disposal;
1333
+ }
1334
+ disposal = Object.freeze({ ok: true });
1335
+ unlock();
1336
+ await reservation;
1337
+ return disposal;
1338
+ },
1339
+ async discard() {
1340
+ if (disposal)
1341
+ return disposal;
1342
+ quarantined = true;
1343
+ disposal = Object.freeze({
1344
+ ok: false,
1345
+ error: new Error("SQLite shared handle quarantined; isolated discard is unavailable."),
1346
+ ownership: "retained"
1347
+ });
1348
+ unlock();
1349
+ await reservation;
1350
+ return disposal;
1351
+ }
1352
+ });
1353
+ publish({ ok: true, value: pin });
1354
+ await slot;
1355
+ });
1356
+ reservation.catch((error) => publish({ ok: false, error, disposition: "not-acquired" }));
1357
+ });
1358
+ },
1359
+ close() {
1360
+ if (pending > 0)
1361
+ throw new Error("Drain SQLite operations before closing the connection.");
1362
+ db.close();
1363
+ closed = true;
1364
+ }
1365
+ });
1366
+ return { ok: true, value: pool };
1367
+ }
1368
+ function createRawSqlitePool(options) {
1369
+ const outcome = openRawSqlitePool(options);
1370
+ if (outcome.ok)
1371
+ return outcome.value;
1372
+ if (outcome.cleanupErrors?.length)
1373
+ throw new AggregateError([outcome.error, ...outcome.cleanupErrors], "SQLite initialization and cleanup failed.");
1374
+ throw outcome.error;
1375
+ }
1376
+
1377
+ // ../../src/core/database/sessionFactory.ts
1378
+ import { mapDatabaseError as mapDatabaseError2 } from "@getstrata/core/database/errors";
1379
+
1380
+ // ../../src/core/database/transactionSession.ts
1381
+ import { AsyncLocalStorage } from "async_hooks";
1382
+ import { mapDatabaseError, PersistenceError as PersistenceError2 } from "@getstrata/core/database/errors";
1383
+ import { runWithTransactionLineage } from "#strata-orm-internal";
1384
+ function rejected(error) {
1385
+ const promise = Promise.reject(error);
1386
+ promise.catch(() => {});
1387
+ return promise;
1388
+ }
1389
+ function failure2(error) {
1390
+ return Object.freeze({ error });
1391
+ }
1392
+ function scopeError() {
1393
+ return new PersistenceError2("DATABASE_TRANSACTION_SCOPE");
1394
+ }
1395
+ function signalAccessor() {
1396
+ const getter = Object.getOwnPropertyDescriptor(AbortSignal.prototype, "aborted")?.get;
1397
+ if (!getter)
1398
+ throw new TypeError("Platform AbortSignal accessors are required.");
1399
+ return getter;
1400
+ }
1401
+ var signalAborted = signalAccessor();
1402
+ var throwIfAborted = AbortSignal.prototype.throwIfAborted;
1403
+ function checkSignal(signal) {
1404
+ if (signal !== undefined)
1405
+ throwIfAborted.call(signal);
1406
+ }
1407
+ function snapshotTransactionOptions(input) {
1408
+ if (!input || typeof input !== "object" || Array.isArray(input))
1409
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1410
+ const prototype = Object.getPrototypeOf(input);
1411
+ if (prototype !== Object.prototype && prototype !== null)
1412
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1413
+ const result = {};
1414
+ for (const key of Reflect.ownKeys(input)) {
1415
+ if (key !== "acquisitionSignal" && key !== "acquisitionMetrics")
1416
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1417
+ const descriptor = Object.getOwnPropertyDescriptor(input, key);
1418
+ if (!descriptor || !("value" in descriptor) || !descriptor.enumerable)
1419
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1420
+ if (descriptor.value !== undefined)
1421
+ result[key] = descriptor.value;
1422
+ }
1423
+ if (result.acquisitionSignal !== undefined)
1424
+ signalAborted.call(result.acquisitionSignal);
1425
+ return Object.freeze(result);
1426
+ }
1427
+ function snapshotStatement(input) {
1428
+ if (!input || typeof input !== "object")
1429
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1430
+ const text = Object.getOwnPropertyDescriptor(input, "text");
1431
+ const params = Object.getOwnPropertyDescriptor(input, "params");
1432
+ if (!text || !("value" in text) || typeof text.value !== "string" || !text.value.trim() || !params || !("value" in params) || !Array.isArray(params.value))
1433
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1434
+ const descriptors = Object.getOwnPropertyDescriptors(params.value);
1435
+ const length = descriptors.length?.value;
1436
+ if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > 4294967295)
1437
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1438
+ const copied = [];
1439
+ for (let index = 0;index < length; index++) {
1440
+ const item = descriptors[String(index)];
1441
+ if (!item || !("value" in item))
1442
+ throw new PersistenceError2("DATABASE_CONFIG_INVALID");
1443
+ copied.push(item.value);
1444
+ }
1445
+ return Object.freeze({ text: text.value, params: Object.freeze(copied) });
1446
+ }
1447
+ function summary(errors) {
1448
+ if (errors.length === 1)
1449
+ return errors[0];
1450
+ const result = new AggregateError([...errors], "Database transaction failures.", {
1451
+ cause: errors[0]
1452
+ });
1453
+ Object.freeze(result.errors);
1454
+ return Object.freeze(result);
1455
+ }
1456
+ function actualResult(business) {
1457
+ return business?.kind === "joined" && business.observation.invoked ? business.observation.body : undefined;
1458
+ }
1459
+ function healthy(business) {
1460
+ return business.kind === "joined" && business.observation.body.ok && !business.observation.strictFailed && !business.observation.retained && !business.requestedRollback && business.sqlFailure === null && !business.poisoned;
1461
+ }
1462
+
1463
+ class TransactionRuntime {
1464
+ context;
1465
+ operations;
1466
+ ownership;
1467
+ attachRegistry;
1468
+ rootSession;
1469
+ ownerForPool;
1470
+ storage = new AsyncLocalStorage;
1471
+ constructor(context, operations, ownership, attachRegistry, rootSession, ownerForPool) {
1472
+ this.context = context;
1473
+ this.operations = operations;
1474
+ this.ownership = ownership;
1475
+ this.attachRegistry = attachRegistry;
1476
+ this.rootSession = rootSession;
1477
+ this.ownerForPool = ownerForPool;
1478
+ }
1479
+ assertOutside() {
1480
+ this.operations.assertActive();
1481
+ if (this.storage.getStore())
1482
+ throw scopeError();
1483
+ }
1484
+ assertBranch(branch) {
1485
+ this.operations.assertActive();
1486
+ if (this.storage.getStore() !== branch || branch.phase === "terminal" || branch.child || branch.poison)
1487
+ throw scopeError();
1488
+ if (!branch.boundary)
1489
+ throw scopeError();
1490
+ branch.boundary.assertWithin();
1491
+ }
1492
+ facade(branch) {
1493
+ if (branch.facade)
1494
+ return branch.facade;
1495
+ let registry;
1496
+ const assertActive = () => this.assertBranch(branch);
1497
+ const run = (work) => {
1498
+ try {
1499
+ assertActive();
1500
+ return this.operations.operation(() => {
1501
+ assertActive();
1502
+ return work();
1503
+ });
1504
+ } catch (error) {
1505
+ return rejected(error);
1506
+ }
1507
+ };
1508
+ const session = {
1509
+ repository: (definition) => registry.repository(definition),
1510
+ model: (definition) => registry.model(definition),
1511
+ dialect: branch.pool.dialect,
1512
+ capabilities: branch.pool.capabilities,
1513
+ execute: (input) => {
1514
+ try {
1515
+ this.assertBranch(branch);
1516
+ const statement = snapshotStatement(input);
1517
+ return this.operations.operation(() => {
1518
+ this.assertBranch(branch);
1519
+ const failed = (error) => {
1520
+ const mapped = mapDatabaseError(error);
1521
+ branch.sqlFailure ??= failure2(mapped);
1522
+ throw mapped;
1523
+ };
1524
+ try {
1525
+ return Promise.resolve(branch.raw.execute(statement)).catch(failed);
1526
+ } catch (error) {
1527
+ return failed(error);
1528
+ }
1529
+ });
1530
+ } catch (error) {
1531
+ return rejected(error);
1532
+ }
1533
+ },
1534
+ transaction: (work) => {
1535
+ try {
1536
+ this.assertBranch(branch);
1537
+ if (typeof work !== "function")
1538
+ throw new TypeError("Transaction callback must be a function.");
1539
+ if (!branch.pool.capabilities.savepoints)
1540
+ throw new PersistenceError2("DATABASE_UNSUPPORTED_CAPABILITY");
1541
+ branch.child = true;
1542
+ const promise = this.operations.operation(() => this.nested(branch, work));
1543
+ promise.then(() => {
1544
+ branch.child = false;
1545
+ }, () => {
1546
+ branch.child = false;
1547
+ });
1548
+ return promise;
1549
+ } catch (error) {
1550
+ return rejected(error);
1551
+ }
1552
+ },
1553
+ afterCommit: (work) => {
1554
+ this.assertBranch(branch);
1555
+ if (typeof work !== "function")
1556
+ throw new TypeError("After-commit callback must be a function.");
1557
+ branch.observers.push(work);
1558
+ },
1559
+ requestRollback: () => {
1560
+ this.assertBranch(branch);
1561
+ branch.rollback = true;
1562
+ }
1563
+ };
1564
+ registry = this.attachRegistry(session, {
1565
+ pool: branch.pool,
1566
+ branch,
1567
+ transactional: true,
1568
+ assertActive,
1569
+ run,
1570
+ registerRestore: (restore) => {
1571
+ assertActive();
1572
+ branch.restores.push({ kind: "restore", restore, consumed: false, outerOnly: false });
1573
+ },
1574
+ root: () => this.rootSession(branch.pool)
1575
+ });
1576
+ branch.facade = Object.freeze(session);
1577
+ return branch.facade;
1578
+ }
1579
+ async business(pool, raw, work, attempt) {
1580
+ const branch = {
1581
+ pool,
1582
+ raw,
1583
+ phase: "open",
1584
+ child: false,
1585
+ rollback: false,
1586
+ sqlFailure: null,
1587
+ poison: null,
1588
+ childFailure: null,
1589
+ observers: [],
1590
+ restores: attempt.restores
1591
+ };
1592
+ attempt.branch = branch;
1593
+ try {
1594
+ const observation = await this.ownership.joined((task) => {
1595
+ branch.boundary = task;
1596
+ try {
1597
+ return work(this.facade(branch));
1598
+ } finally {
1599
+ branch.phase = "joining";
1600
+ }
1601
+ }, (invoke) => this.storage.run(branch, () => runWithTransactionLineage(this.ownerForPool(branch.pool), () => branch.phase !== "terminal", invoke)));
1602
+ return Object.freeze({
1603
+ kind: "joined",
1604
+ observation,
1605
+ requestedRollback: branch.rollback,
1606
+ sqlFailure: branch.sqlFailure,
1607
+ poisoned: branch.poison !== null,
1608
+ childFailure: branch.childFailure,
1609
+ observers: Object.freeze([...branch.observers])
1610
+ });
1611
+ } catch (error) {
1612
+ return Object.freeze({ kind: "not-admitted", error });
1613
+ } finally {
1614
+ branch.phase = "terminal";
1615
+ }
1616
+ }
1617
+ newAttempt() {
1618
+ return {
1619
+ stage: Object.freeze({ kind: "callback-not-entered" }),
1620
+ nativeFailure: null,
1621
+ nativeState: "idle",
1622
+ releaseAcknowledged: false,
1623
+ checkoutFailed: false,
1624
+ restores: []
1625
+ };
1626
+ }
1627
+ async control(task, attempt, pool, native, work, admission) {
1628
+ let continuation;
1629
+ const callback = task.bindNative((raw) => {
1630
+ if (attempt.stage.kind !== "callback-not-entered")
1631
+ return rejected(new PersistenceError2("DATABASE_TRANSACTION_FAILED"));
1632
+ attempt.stage = Object.freeze({ kind: "callback-running" });
1633
+ continuation = (async () => {
1634
+ try {
1635
+ checkSignal(admission);
1636
+ const business = await this.business(pool, raw, work, attempt);
1637
+ attempt.business = business;
1638
+ const decision = Object.freeze({
1639
+ finish: healthy(business) ? "commit" : "rollback",
1640
+ result: business
1641
+ });
1642
+ attempt.stage = Object.freeze({ kind: "decided", decision });
1643
+ return decision;
1644
+ } catch (error) {
1645
+ attempt.stage = Object.freeze({ kind: "callback-failed", error });
1646
+ throw error;
1647
+ }
1648
+ })();
1649
+ continuation.catch(() => {});
1650
+ return continuation;
1651
+ });
1652
+ try {
1653
+ attempt.terminal = await native(callback);
1654
+ attempt.nativeState = attempt.terminal.nativeState;
1655
+ if (attempt.terminal.failure || attempt.terminal.data === "unknown") {
1656
+ if (attempt.branch)
1657
+ attempt.branch.poison = attempt.terminal.failure ?? failure2(new PersistenceError2("DATABASE_TRANSACTION_UNKNOWN"));
1658
+ }
1659
+ } catch (error) {
1660
+ attempt.nativeFailure = failure2(error);
1661
+ attempt.nativeState = "unknown";
1662
+ if (attempt.branch)
1663
+ attempt.branch.poison = attempt.nativeFailure;
1664
+ } finally {
1665
+ if (continuation)
1666
+ await continuation.catch(() => {});
1667
+ }
1668
+ }
1669
+ evidence(attempt, joined) {
1670
+ const errors = [];
1671
+ const business = attempt.business;
1672
+ if (attempt.preAdmissionFailure)
1673
+ errors.push(attempt.preAdmissionFailure.error);
1674
+ if (business?.kind === "not-admitted")
1675
+ errors.push(business.error);
1676
+ else if (business?.kind === "joined" && business.observation.invoked && !business.observation.body.ok)
1677
+ errors.push(business.observation.body.error);
1678
+ if (business?.kind === "joined" && business.childFailure)
1679
+ errors.push(business.childFailure.error);
1680
+ if (attempt.stage.kind === "callback-failed")
1681
+ errors.push(attempt.stage.error);
1682
+ const phases = attempt.terminal?.phases ?? [];
1683
+ const failedPhases = phases.filter((phase) => phase.failure !== null);
1684
+ for (const phase of failedPhases)
1685
+ if (phase.failure)
1686
+ errors.push(phase.failure.error);
1687
+ if (attempt.terminal?.failure && failedPhases.length === 0 && attempt.stage.kind !== "callback-failed")
1688
+ errors.push(attempt.terminal.failure.error);
1689
+ if (attempt.nativeFailure)
1690
+ errors.push(attempt.nativeFailure.error);
1691
+ for (const occurrence of joined.strict)
1692
+ errors.push(occurrence.error);
1693
+ return errors;
1694
+ }
1695
+ result(attempt, joined, nested) {
1696
+ const terminal = attempt.terminal;
1697
+ const business = attempt.business;
1698
+ const result = actualResult(business);
1699
+ const data = terminal?.data === "released" ? "unknown" : terminal?.data ?? (attempt.checkoutFailed || attempt.stage.kind === "callback-not-entered" && !attempt.nativeFailure ? "not-started" : "unknown");
1700
+ const errors = this.evidence(attempt, joined);
1701
+ if (!joined.body.ok && joined.invoked)
1702
+ errors.push(joined.body.error);
1703
+ const intendedRollback = business?.kind === "joined" && business.requestedRollback;
1704
+ const sqlFailure = business?.kind === "joined" ? business.sqlFailure : null;
1705
+ const acknowledged = nested ? terminal?.data === "released" : terminal?.data === "committed";
1706
+ const rolledBack = terminal?.data === "rolled-back";
1707
+ if (!errors.length && !joined.strictFailed && !joined.retained && result?.ok && (acknowledged && business !== undefined && healthy(business) || rolledBack && intendedRollback && !sqlFailure))
1708
+ return result.value;
1709
+ if (rolledBack && result && !result.ok && errors.length === 1 && !joined.strictFailed && !joined.retained)
1710
+ throw result.error;
1711
+ if (rolledBack && attempt.stage.kind === "callback-failed" && errors.length === 1 && !joined.strictFailed && !joined.retained)
1712
+ throw attempt.stage.error;
1713
+ const options = {
1714
+ data,
1715
+ ...result ? { result } : {},
1716
+ ...errors.length ? { cause: summary(errors) } : {}
1717
+ };
1718
+ if (data === "unknown")
1719
+ throw new PersistenceError2("DATABASE_TRANSACTION_UNKNOWN", options);
1720
+ if (rolledBack && result?.ok && sqlFailure && errors.length === 0)
1721
+ throw new PersistenceError2("DATABASE_TRANSACTION_ROLLBACK_ONLY", {
1722
+ ...options,
1723
+ cause: sqlFailure.error
1724
+ });
1725
+ throw new PersistenceError2("DATABASE_TRANSACTION_FAILED", options);
1726
+ }
1727
+ markUnknown(entries) {
1728
+ for (const entry of entries) {
1729
+ if (entry.kind === "child")
1730
+ this.markUnknown(entry.entries);
1731
+ else
1732
+ entry.outerOnly = true;
1733
+ }
1734
+ }
1735
+ async restoreHistory(task, entries, outer) {
1736
+ for (let index = entries.length - 1;index >= 0; index--) {
1737
+ const entry = entries[index];
1738
+ if (!entry)
1739
+ continue;
1740
+ if (entry.kind === "child")
1741
+ await this.restoreHistory(task, entry.entries, outer);
1742
+ else if (!entry.consumed && (outer || !entry.outerOnly)) {
1743
+ entry.consumed = true;
1744
+ await task.finalize(() => {
1745
+ entry.restore();
1746
+ return;
1747
+ });
1748
+ }
1749
+ }
1750
+ }
1751
+ async nested(parent, work) {
1752
+ const attempt = this.newAttempt();
1753
+ parent.restores.push({ kind: "child", entries: attempt.restores });
1754
+ const joined = await this.ownership.joined(async (task) => {
1755
+ await this.control(task, attempt, parent.pool, (callback) => parent.raw.savepoint(callback), work);
1756
+ if (attempt.terminal?.data === "rolled-back")
1757
+ await this.restoreHistory(task, attempt.restores, false);
1758
+ else if (attempt.terminal?.data !== "released")
1759
+ this.markUnknown(attempt.restores);
1760
+ });
1761
+ const unsafe = !attempt.terminal || attempt.terminal.data !== "released" && attempt.terminal.data !== "rolled-back" || attempt.nativeFailure !== null;
1762
+ if (unsafe)
1763
+ parent.poison = failure2(new PersistenceError2("DATABASE_TRANSACTION_UNKNOWN"));
1764
+ if (attempt.terminal?.data === "released" && attempt.business?.kind === "joined" && healthy(attempt.business) && !joined.strictFailed && !joined.retained)
1765
+ for (const observer of attempt.business.observers)
1766
+ parent.observers.push(observer);
1767
+ try {
1768
+ return this.result(attempt, joined, true);
1769
+ } catch (error) {
1770
+ if (unsafe && !joined.strictFailed)
1771
+ parent.childFailure ??= failure2(error);
1772
+ throw error;
1773
+ }
1774
+ }
1775
+ run(pool, work, options = {}) {
1776
+ try {
1777
+ this.assertOutside();
1778
+ if (typeof work !== "function")
1779
+ throw new TypeError("Transaction callback must be a function.");
1780
+ const settings = snapshotTransactionOptions(options);
1781
+ if (settings.acquisitionSignal !== undefined && !pool.capabilities.cancellableCheckout || settings.acquisitionMetrics !== undefined && !pool.capabilities.observableCheckout)
1782
+ throw new PersistenceError2("DATABASE_UNSUPPORTED_CAPABILITY");
1783
+ checkSignal(settings.acquisitionSignal);
1784
+ const admission = settings.acquisitionSignal;
1785
+ const checkout = Object.freeze({
1786
+ ...pool.capabilities.cancellableCheckout ? { signal: admission ?? this.context.signal } : {},
1787
+ ...settings.acquisitionMetrics !== undefined ? { metrics: settings.acquisitionMetrics } : {}
1788
+ });
1789
+ return this.operations.operation(async () => {
1790
+ const attempt = this.newAttempt();
1791
+ const joined = await this.ownership.joined(async (task) => {
1792
+ let pin;
1793
+ let opened = false;
1794
+ try {
1795
+ pin = await task.acquire({
1796
+ name: "database.transaction.pin",
1797
+ open: () => {
1798
+ opened = true;
1799
+ return pool.checkout(checkout);
1800
+ },
1801
+ close: async (owned) => {
1802
+ const ack = await (attempt.nativeState === "idle" ? owned.release() : owned.discard());
1803
+ if (!ack.ok)
1804
+ throw ack.error;
1805
+ attempt.releaseAcknowledged = true;
1806
+ }
1807
+ });
1808
+ } catch (error) {
1809
+ attempt.checkoutFailed = true;
1810
+ if (!opened)
1811
+ attempt.preAdmissionFailure = failure2(error);
1812
+ return;
1813
+ }
1814
+ await this.control(task, attempt, pool, (callback) => pin.begin(callback), work, admission);
1815
+ if (attempt.terminal?.data === "rolled-back")
1816
+ await this.restoreHistory(task, attempt.restores, true);
1817
+ });
1818
+ const value = this.result(attempt, joined, false);
1819
+ if (attempt.terminal?.data === "committed" && attempt.releaseAcknowledged && attempt.business?.kind === "joined") {
1820
+ for (const observer of attempt.business.observers) {
1821
+ let observed;
1822
+ try {
1823
+ observed = await this.ownership.joined(() => observer(), (invoke) => this.storage.run(undefined, invoke));
1824
+ } catch (error) {
1825
+ throw new PersistenceError2("DATABASE_POST_COMMIT_FAILED", {
1826
+ data: "committed",
1827
+ cause: error,
1828
+ result: actualResult(attempt.business)
1829
+ });
1830
+ }
1831
+ if (!observed.body.ok || observed.strictFailed || observed.retained) {
1832
+ const errors = [];
1833
+ if (observed.invoked && !observed.body.ok)
1834
+ errors.push(observed.body.error);
1835
+ for (const item of observed.strict)
1836
+ errors.push(item.error);
1837
+ throw new PersistenceError2("DATABASE_POST_COMMIT_FAILED", {
1838
+ data: "committed",
1839
+ result: actualResult(attempt.business),
1840
+ ...errors.length ? { cause: summary(errors) } : {}
1841
+ });
1842
+ }
1843
+ }
1844
+ }
1845
+ return value;
1846
+ });
1847
+ } catch (error) {
1848
+ return rejected(error);
1849
+ }
1850
+ }
1851
+ }
1852
+
1853
+ // ../../src/core/database/sessionFactory.ts
1854
+ function rejected2(error) {
1855
+ const promise = Promise.reject(error);
1856
+ promise.catch(() => {});
1857
+ return promise;
1858
+ }
1859
+ function createDatabaseSession(manager, context, operations, ownership, prepared) {
1860
+ const factory = createBoundRegistryFactory(prepared, context, ownership, (pool) => manager.configuredPool(pool));
1861
+ const transactions = new TransactionRuntime(context, operations, ownership, (session, authority) => factory.attach(session, authority), (pool) => selectPool(pool), (pool) => Object.freeze({ app: prepared.app, configuredPool: manager.configuredPool(pool) }));
1862
+ const cache = new Map;
1863
+ const selectPool = (pool) => {
1864
+ const existing = cache.get(pool);
1865
+ if (existing)
1866
+ return existing;
1867
+ let registry;
1868
+ const assertActive = () => transactions.assertOutside();
1869
+ const run = (work) => {
1870
+ try {
1871
+ assertActive();
1872
+ return operations.operation(() => {
1873
+ assertActive();
1874
+ return work();
1875
+ });
1876
+ } catch (error) {
1877
+ return rejected2(error);
1878
+ }
1879
+ };
1880
+ const session = {
1881
+ repository: (definition) => registry.repository(definition),
1882
+ model: (definition) => registry.model(definition),
1883
+ dialect: pool.dialect,
1884
+ capabilities: pool.capabilities,
1885
+ execute: (input) => {
1886
+ try {
1887
+ transactions.assertOutside();
1888
+ const statement = snapshotStatement(input);
1889
+ return operations.operation(() => {
1890
+ transactions.assertOutside();
1891
+ try {
1892
+ return Promise.resolve(pool.execute(statement)).catch((error) => {
1893
+ throw mapDatabaseError2(error);
1894
+ });
1895
+ } catch (error) {
1896
+ throw mapDatabaseError2(error);
1897
+ }
1898
+ });
1899
+ } catch (error) {
1900
+ return rejected2(error);
1901
+ }
1902
+ },
1903
+ transaction: (work, options) => transactions.run(pool, work, options),
1904
+ connection: (connection) => {
1905
+ transactions.assertOutside();
1906
+ return selectPool(manager.connection(connection));
1907
+ }
1908
+ };
1909
+ registry = factory.attach(session, {
1910
+ pool,
1911
+ branch: session,
1912
+ transactional: false,
1913
+ assertActive,
1914
+ run,
1915
+ registerRestore: () => {
1916
+ assertActive();
1917
+ },
1918
+ root: () => session
1919
+ });
1920
+ Object.freeze(session);
1921
+ cache.set(pool, session);
1922
+ return session;
1923
+ };
1924
+ return selectPool(manager.connection());
1925
+ }
1926
+
1927
+ // ../../src/core/database/bindings.ts
1928
+ function invalid() {
1929
+ throw new PersistenceError3("DATABASE_CONFIG_INVALID");
1930
+ }
1931
+ function record(input, allowed) {
1932
+ if (input === null || typeof input !== "object" || Array.isArray(input))
1933
+ return invalid();
1934
+ const prototype = Object.getPrototypeOf(input);
1935
+ if (prototype !== Object.prototype && prototype !== null)
1936
+ return invalid();
1937
+ const result = Object.create(null);
1938
+ for (const key of Reflect.ownKeys(input)) {
1939
+ if (typeof key !== "string" || allowed && !allowed.includes(key))
1940
+ return invalid();
1941
+ const descriptor = Object.getOwnPropertyDescriptor(input, key);
1942
+ if (!descriptor || !("value" in descriptor) || !descriptor.enumerable)
1943
+ return invalid();
1944
+ result[key] = descriptor.value;
1945
+ }
1946
+ return result;
1947
+ }
1948
+ function nonempty(value) {
1949
+ if (typeof value !== "string" || value.trim().length === 0)
1950
+ invalid();
1951
+ }
1952
+ function integer(value, minimum) {
1953
+ if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum)
1954
+ invalid();
1955
+ }
1956
+ function connectionOptions(input) {
1957
+ const all = record(input);
1958
+ if (all.driver === "sqlite") {
1959
+ if (Object.keys(all).some((key) => !["driver", "filename"].includes(key)))
1960
+ invalid();
1961
+ nonempty(all.filename);
1962
+ return all;
1963
+ }
1964
+ if (all.driver !== "pgsql" && all.driver !== "mysql")
1965
+ return invalid();
1966
+ const allowed = all.driver === "pgsql" ? ["driver", "url", "max", "idleTimeout", "maxLifetime", "connectionTimeout"] : ["driver", "url", "max"];
1967
+ if (Object.keys(all).some((key) => !allowed.includes(key)))
1968
+ invalid();
1969
+ const options = Object.fromEntries(Object.entries(all).filter(([, value]) => value !== undefined));
1970
+ nonempty(options.url);
1971
+ try {
1972
+ const url = new URL(options.url);
1973
+ if (!(all.driver === "mysql" ? ["mysql:"] : ["postgres:", "postgresql:"]).includes(url.protocol))
1974
+ return invalid();
1975
+ } catch {
1976
+ return invalid();
1977
+ }
1978
+ if (options.max !== undefined)
1979
+ integer(options.max, 1);
1980
+ for (const key of ["idleTimeout", "maxLifetime", "connectionTimeout"]) {
1981
+ const value = options[key];
1982
+ if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value) || value < 0))
1983
+ invalid();
1984
+ }
1985
+ return options;
1986
+ }
1987
+ function snapshotDatabaseDefinition(input) {
1988
+ const definition = record(input, [
1989
+ "default",
1990
+ "connections",
1991
+ "repositories",
1992
+ "models",
1993
+ "repositoryEffects",
1994
+ "preparation"
1995
+ ]);
1996
+ nonempty(definition.default);
1997
+ const connections = record(definition.connections);
1998
+ const copied = Object.create(null);
1999
+ for (const [name, options] of Object.entries(connections)) {
2000
+ nonempty(name);
2001
+ copied[name] = connectionOptions(options);
2002
+ }
2003
+ if (!Object.hasOwn(copied, definition.default))
2004
+ invalid();
2005
+ return copyApplicationConfig({
2006
+ default: definition.default,
2007
+ connections: copied
2008
+ });
2009
+ }
2010
+ async function openPool(options) {
2011
+ switch (options.driver) {
2012
+ case "sqlite":
2013
+ return openRawSqlitePool(options);
2014
+ case "pgsql":
2015
+ return { ok: true, value: await createRawPostgresPool(options) };
2016
+ case "mysql":
2017
+ return { ok: true, value: await createRawMysqlPool(options) };
2018
+ }
2019
+ }
2020
+ function createDatabaseBindings(definition) {
2021
+ const snapshot = snapshotDatabaseDefinition(definition);
2022
+ const registrySnapshot = snapshotRegistry(definition.repositories, definition.models, definition.repositoryEffects);
2023
+ const preparation = definition.preparation ?? [];
2024
+ if (!Array.isArray(preparation))
2025
+ invalid();
2026
+ const preparationTokens = Array.from({ length: preparation.length }, (_, index) => {
2027
+ const descriptor = Object.getOwnPropertyDescriptor(preparation, String(index));
2028
+ if (!descriptor || !("value" in descriptor))
2029
+ return invalid();
2030
+ assertServiceToken(descriptor.value);
2031
+ return descriptor.value;
2032
+ });
2033
+ const preparedToken = createServiceToken("core.database.registry");
2034
+ const entries = Object.entries(snapshot.connections).map(([name, options]) => ({
2035
+ name,
2036
+ options,
2037
+ token: createServiceToken(`core.database.pool.${name}`)
2038
+ }));
2039
+ const poolTokens = entries.map((entry) => entry.token);
2040
+ const declarations = entries.map(({ name, options, token }) => resourceService(token, {
2041
+ lifetime: "application",
2042
+ dependencies: [preparedToken],
2043
+ create: () => ({
2044
+ name: `core.database.pool.${name}`,
2045
+ open: () => openPool(options),
2046
+ close: (pool) => pool.close()
2047
+ })
2048
+ }));
2049
+ declarations.unshift(service(DATABASE_OWNERSHIP_TOKEN, {
2050
+ lifetime: "application",
2051
+ dependencies: [],
2052
+ create: () => createDatabaseOwnership(snapshot.connections)
2053
+ }), service(preparedToken, {
2054
+ lifetime: "application",
2055
+ dependencies: [
2056
+ DATABASE_OWNERSHIP_TOKEN,
2057
+ ...registrySnapshot.dependencies,
2058
+ ...preparationTokens
2059
+ ],
2060
+ create: (ownership, ...values) => prepareRegistry(registrySnapshot, values.slice(0, registrySnapshot.dependencies.length), ownership.app)
2061
+ }));
2062
+ declarations.push(service(DATABASE_MANAGER_TOKEN, {
2063
+ lifetime: "application",
2064
+ dependencies: [DATABASE_OWNERSHIP_TOKEN, ...poolTokens],
2065
+ create: (ownership, ...pools) => new DatabaseManager(snapshot.default, entries.map(({ name }, index) => [name, pools[index]]), ownership)
2066
+ }));
2067
+ declarations.push(service(DATABASE_SESSION_TOKEN, {
2068
+ lifetime: "execution",
2069
+ dependencies: [
2070
+ DATABASE_MANAGER_TOKEN,
2071
+ preparedToken,
2072
+ CORE_EXECUTION_CONTEXT_TOKEN,
2073
+ CORE_EXECUTION_OPERATIONS_TOKEN,
2074
+ CORE_EXECUTION_OWNERSHIP_TOKEN
2075
+ ],
2076
+ create: (manager, prepared, context, operations, ownership) => createDatabaseSession(manager, context, operations, ownership, prepared)
2077
+ }));
2078
+ return Object.freeze(declarations);
2079
+ }
2080
+ export {
2081
+ createDatabaseBindings
2082
+ };