@murumets-ee/db 0.1.1 → 0.1.2

package/package.json

@@ -1,18 +1,16 @@
 {
   "name": "@murumets-ee/db",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "license": "Elastic-2.0",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": "./dist/index.js"
     },
     "./test-utils": {
       "types": "./dist/test-utils.d.ts",
-      "import": "./dist/test-utils.js",
-      "require": "./dist/test-utils.cjs"
+      "import": "./dist/test-utils.js"
     }
   },
   "files": [
@@ -23,7 +21,7 @@
     "postgres": "^3.4.5"
   },
   "devDependencies": {
-    "drizzle-kit": "^0.27.2",
+    "drizzle-kit": "^0.31.10",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"

package/dist/index.cjs

@@ -1,15 +0,0 @@
-'use strict';var postgresJs=require('drizzle-orm/postgres-js'),g=require('postgres'),fs=require('fs'),promises=require('fs/promises'),path=require('path'),drizzleOrm=require('drizzle-orm');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var g__default=/*#__PURE__*/_interopDefault(g);function S(a){let t=g__default.default(a.url,{max:a.poolMax||10,idle_timeout:20,max_lifetime:1800});return postgresJs.drizzle(t)}function b(a){let t=a.readOnlyUrl||a.url,n=g__default.default(t,{max:a.poolMax||10,idle_timeout:20,max_lifetime:1800,connection:{application_name:"toolkit_readonly"},onnotice:()=>{}});return n.unsafe("SET default_transaction_read_only = on").catch(()=>{}),postgresJs.drizzle(n)}async function d(a){await a.execute(drizzleOrm.sql`
-    CREATE TABLE IF NOT EXISTS _toolkit_migrations (
-      id SERIAL PRIMARY KEY,
-      namespace VARCHAR(50) NOT NULL,
-      name VARCHAR(255) NOT NULL,
-      applied_at TIMESTAMP NOT NULL DEFAULT NOW(),
-      UNIQUE(namespace, name)
-    )
-  `);}async function h(a){let t=[],n=path.join(a,"migrations",".toolkit");if(fs.existsSync(n)){let o=await promises.readdir(n);for(let e of o)(e.endsWith(".sql")||e.endsWith(".ts"))&&t.push({path:path.join(n,e),namespace:"toolkit",name:e});}let i=path.join(a,"migrations");if(fs.existsSync(i)){let o=await promises.readdir(i);for(let e of o)e!==".toolkit"&&(e.endsWith(".sql")||e.endsWith(".ts"))&&t.push({path:path.join(i,e),namespace:"project",name:e});}let r=t.filter(o=>o.namespace==="toolkit").sort((o,e)=>o.name.localeCompare(e.name)),s=t.filter(o=>o.namespace==="project").sort((o,e)=>o.name.localeCompare(e.name));return [...r,...s]}async function y(a,t){await d(a);let n=await h(t),i=await a.execute(drizzleOrm.sql`
-    SELECT namespace, name FROM _toolkit_migrations
-    ORDER BY applied_at ASC
-  `),r=new Set(i.map(e=>`${e.namespace}:${e.name}`)),s=[],o=[];for(let e of n){let M=`${e.namespace}:${e.name}`;r.has(M)?s.push(e):o.push(e);}return {applied:s,pending:o}}async function x(a,t){await d(a);let{pending:n}=await y(a,t);if(n.length===0){console.log("No pending migrations");return}console.log(`Running ${n.length} pending migrations...`);for(let i of n){console.log(`  Applying ${i.namespace}/${i.name}...`);try{let r=await promises.readFile(i.path,"utf-8");await a.transaction(async s=>{await s.execute(drizzleOrm.sql.raw(r)),await s.execute(drizzleOrm.sql`
-          INSERT INTO _toolkit_migrations (namespace, name)
-          VALUES (${i.namespace}, ${i.name})
-        `);}),console.log(`  \u2713 Applied ${i.namespace}/${i.name}`);}catch(r){throw console.error(`  \u2717 Failed to apply ${i.namespace}/${i.name}:`,r),r}}console.log(`Successfully applied ${n.length} migrations`);}var m=class{schemas=new Map;register(t,n){this.schemas.set(t,n);}get(t){return this.schemas.get(t)}all(){let t={};for(let[n,i]of this.schemas.entries())t[n]=i;return t}has(t){return this.schemas.has(t)}},R=new m;function A(){return new m}exports.createDbClient=S;exports.createReadOnlyClient=b;exports.createSchemaRegistry=A;exports.discoverMigrations=h;exports.getMigrationStatus=y;exports.runMigrations=x;exports.schemaRegistry=R;

package/dist/index.d.cts

@@ -1,74 +0,0 @@
-import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import { PgTableWithColumns } from 'drizzle-orm/pg-core';
-
-interface DbConfig {
-    url: string;
-    readOnlyUrl?: string;
-    poolMin?: number;
-    poolMax?: number;
-}
-/**
- * Create a full read-write database client
- */
-declare function createDbClient(config: DbConfig): PostgresJsDatabase;
-/**
- * Create a read-only database client
- * Sets default_transaction_read_only=on to prevent writes even if SQL injection occurs
- */
-declare function createReadOnlyClient(config: DbConfig): PostgresJsDatabase;
-
-interface MigrationSource {
-    path: string;
-    namespace: 'toolkit' | 'project';
-    name: string;
-}
-interface MigrationStatus {
-    applied: MigrationSource[];
-    pending: MigrationSource[];
-}
-/**
- * Discover migrations from both toolkit (.toolkit/) and project (migrations/) directories
- */
-declare function discoverMigrations(projectRoot: string): Promise<MigrationSource[]>;
-/**
- * Get the status of migrations (applied vs pending)
- */
-declare function getMigrationStatus(db: PostgresJsDatabase, projectRoot: string): Promise<MigrationStatus>;
-/**
- * Run pending migrations
- */
-declare function runMigrations(db: PostgresJsDatabase, projectRoot: string): Promise<void>;
-
-/**
- * Schema registry for storing Drizzle schemas
- * This will be populated by @org/entity when schemas are generated from entity definitions
- *
- * We use PgTableWithColumns<any> because entity table schemas are dynamic (columns
- * not known at compile time) and we need runtime property access (.id, .status, etc.).
- * AnyPgTable won't work here — it doesn't expose column accessors.
- */
-type AnyTable = PgTableWithColumns<any>;
-interface SchemaRegistry {
-    register(name: string, schema: AnyTable): void;
-    get(name: string): AnyTable | undefined;
-    all(): Record<string, AnyTable>;
-    has(name: string): boolean;
-}
-declare class SchemaRegistryImpl implements SchemaRegistry {
-    private schemas;
-    register(name: string, schema: AnyTable): void;
-    get(name: string): AnyTable | undefined;
-    all(): Record<string, AnyTable>;
-    has(name: string): boolean;
-}
-/**
- * Global schema registry instance
- * Entities will register their schemas here when they are defined
- */
-declare const schemaRegistry: SchemaRegistryImpl;
-/**
- * Create a new isolated schema registry (useful for testing)
- */
-declare function createSchemaRegistry(): SchemaRegistry;
-
-export { type DbConfig, type MigrationSource, type MigrationStatus, type SchemaRegistry, createDbClient, createReadOnlyClient, createSchemaRegistry, discoverMigrations, getMigrationStatus, runMigrations, schemaRegistry };

package/dist/test-utils.cjs

@@ -1 +0,0 @@
-'use strict';var drizzleOrm=require('drizzle-orm'),postgresJs=require('drizzle-orm/postgres-js'),T=require('postgres');var _documentCurrentScript=typeof document!=='undefined'?document.currentScript:null;function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var T__default=/*#__PURE__*/_interopDefault(T);async function S(){let a=process.env.DATABASE_TEST_URL||process.env.DATABASE_URL;if(!a)throw new Error("DATABASE_TEST_URL (or DATABASE_URL) env var is required for integration tests");let r=`test_${crypto.randomUUID().replaceAll("-","").slice(0,12)}`,n=T__default.default(a,{max:3,idle_timeout:10}),e=postgresJs.drizzle(n);return await e.execute(drizzleOrm.sql.raw(`CREATE SCHEMA "${r}"`)),await e.execute(drizzleOrm.sql.raw(`SET search_path TO "${r}", public`)),{db:e,schema:r,async push(c){let{createRequire:u}=await import('module'),p=u((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('test-utils.cjs', document.baseURI).href))),{pushSchema:m}=p("drizzle-kit/api"),l=new Proxy(e,{get(o,i,w){return i==="execute"?async(...A)=>{let t=await o.execute(...A);return Array.isArray(t)&&!("rows"in t)&&Object.defineProperty(t,"rows",{value:[...t],enumerable:false}),t}:Reflect.get(o,i,w)}});await(await m(c,l)).apply();},async cleanup(){await e.execute(drizzleOrm.sql.raw(`DROP SCHEMA IF EXISTS "${r}" CASCADE`)),await n.end();}}}exports.createTestDb=S;

package/dist/test-utils.d.cts

@@ -1,27 +0,0 @@
-import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-
-interface TestDb {
-    db: PostgresJsDatabase;
-    schema: string;
-    /** Push Drizzle table definitions to the test schema (uses drizzle-kit/api) */
-    push: (schemas: Record<string, unknown>) => Promise<void>;
-    cleanup: () => Promise<void>;
-}
-/**
- * Create an isolated test database using a unique PostgreSQL schema.
- * Each test suite gets its own schema so tests can run in parallel safely.
- *
- * Requires `DATABASE_TEST_URL` env var pointing to a running PostgreSQL instance.
- * Falls back to `DATABASE_URL` if test URL is not set.
- *
- * Usage:
- * ```ts
- * const testDb = await createTestDb()
- * await testDb.push({ articles: articlesTable, entity_refs: entityRefsTable })
- * // ... run tests with testDb.db ...
- * await testDb.cleanup()
- * ```
- */
-declare function createTestDb(): Promise<TestDb>;
-
-export { type TestDb, createTestDb };