arkormx 2.0.0-next.0 → 2.0.0-next.2

package/README.md

@@ -7,12 +7,12 @@
 [![Deploy Documentation](https://github.com/arkstack-hq/arkormx/actions/workflows/deploy-docs.yml/badge.svg)](https://github.com/arkstack-hq/arkormx/actions/workflows/deploy-docs.yml)
 [![codecov](https://codecov.io/gh/arkstack-hq/arkormx/graph/badge.svg?token=ls1VVoFkYh)](https://codecov.io/gh/arkstack-hq/arkormx)
 
-Arkormˣ is a framework-agnostic ORM designed to run anywhere Node.js runs. It brings a familiar model layer and fluent query builder on top of Prisma delegates, enabling clean, modern, and type-safe development.
+Arkormˣ is a framework-agnostic ORM designed to run anywhere Node.js runs. It brings a familiar model layer and fluent query builder on top of adapter-backed execution, with Prisma compatibility kept during the current transition window.
 
 ## Features
 
-- Arkormˣ is built on top of Prisma, providing a familiar and powerful API for database interactions.
-- Delegate-backed query execution with practical ORM ergonomics.
+- Adapter-backed query execution with practical ORM ergonomics.
+- Adapter-first runtime setup with Kysely/Postgres support and a Prisma compatibility adapter during migration.
 - End-to-end guides for setup, querying, relationships, migrations, and CLI usage.
 - Full TypeScript support, providing strong typing and improved developer experience.
 - Follows best practices for security, ensuring your data is protected.
@@ -26,27 +26,49 @@ Arkormˣ is a framework-agnostic ORM designed to run anywhere Node.js runs. It b
 Stable release:
 
 ```sh
-pnpm add arkormx @prisma/client
-pnpm add -D prisma
+pnpm add arkormx kysely pg
 ```
 
 Preview release (`next`):
 
 ```sh
-pnpm add arkormx@next @prisma/client
-pnpm add -D prisma
+pnpm add arkormx@next kysely pg
 ```
 
 ### Configuration
 
+Primary runtime path:
+
+```ts
+import { createKyselyAdapter, defineConfig } from 'arkormx';
+import { Kysely, PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+
+export default defineConfig({
+  adapter: createKyselyAdapter(
+    new Kysely<Record<string, never>>({
+      dialect: new PostgresDialect({
+        pool: new Pool({
+          connectionString: process.env.DATABASE_URL,
+        }),
+      }),
+    }),
+  ),
+});
+```
+
+Optional compatibility/runtime config for CLI and transaction helpers:
+
 Create `arkormx.config.js` in your project root:
 
 ```ts
 import { defineConfig } from 'arkormx';
 import { PrismaClient } from '@prisma/client';
 
+const prisma = new PrismaClient();
+
 export default defineConfig({
-  prisma: new PrismaClient(...),
+  prisma: () => prisma,
 });
 ```
 
@@ -57,15 +79,21 @@ Or run the Arkormˣ CLI command `npx arkorm init` to initialize your project alo
 ```ts
 import { Model } from 'arkormx';
 
-export class User extends Model<'users'> {
-  protected static override delegate = 'users'; // not required if your model name matches the delegate name or the pluralized form of it
-}
+type UserAttributes = {
+  id: number;
+  email: string;
+  name: string;
+  isActive: boolean;
+};
+
+export class User extends Model<UserAttributes> {}
 ```
 
-### Generate Prisma client
+### Optional Prisma compatibility
 
 ```sh
-pnpm prisma generate
+pnpm add @prisma/client
+pnpm add -D prisma
 ```
 
 ### Run queries
@@ -98,6 +126,7 @@ await User.transaction(async () => {
 
 - [Setup](https://arkormx.toneflix.net/guide/setup)
 - [Configuration](https://arkormx.dev/guide/configuration)
+- [Prisma Compatibility](https://arkormx.dev/guide/prisma-compatibility)
 - [Typing](https://arkormx.dev/guide/typing)
 - [Models](https://arkormx.dev/guide/models)
 - [Query Builder](https://arkormx.dev/guide/query-builder)

package/dist/cli.mjs

@@ -1458,6 +1458,7 @@ const userConfig = {
 let runtimeConfigLoaded = false;
 let runtimeConfigLoadingPromise;
 let runtimeClientResolver;
+let runtimeAdapter;
 let runtimePaginationURLDriverFactory;
 let runtimePaginationCurrentPageResolver;
 const transactionClientStorage = new AsyncLocalStorage();
@@ -1474,6 +1475,12 @@ const mergePathConfig = (paths) => {
 		...incoming
 	};
 };
+const bindAdapterToModels = (adapter, models) => {
+	models.forEach((model) => {
+		model.setAdapter(adapter);
+	});
+	return adapter;
+};
 /**
 * Get the user-provided ArkORM configuration. 
 * 
@@ -1493,15 +1500,35 @@ const getUserConfig = (key) => {
 const configureArkormRuntime = (prisma, options = {}) => {
 	const nextConfig = {
 		...userConfig,
-		prisma,
 		paths: mergePathConfig(options.paths)
 	};
+	nextConfig.prisma = prisma;
 	if (options.pagination !== void 0) nextConfig.pagination = options.pagination;
+	if (options.adapter !== void 0) nextConfig.adapter = options.adapter;
+	if (options.boot !== void 0) nextConfig.boot = options.boot;
 	if (options.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
 	Object.assign(userConfig, { ...nextConfig });
 	runtimeClientResolver = prisma;
+	runtimeAdapter = options.adapter;
 	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
 	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
+	options.boot?.({
+		prisma: resolveClient(prisma),
+		bindAdapter: bindAdapterToModels
+	});
+};
+/**
+* Resolve a Prisma client instance from the provided resolver, which can be either
+* a direct client instance or a function that returns a client instance.
+* 
+* @param resolver 
+* @returns 
+*/
+const resolveClient = (resolver) => {
+	if (!resolver) return void 0;
+	const client = typeof resolver === "function" ? resolver() : resolver;
+	if (!client || typeof client !== "object") return void 0;
+	return client;
 };
 /**
 * Resolve and apply the ArkORM configuration from an imported module. 
@@ -1513,8 +1540,10 @@ const configureArkormRuntime = (prisma, options = {}) => {
 */
 const resolveAndApplyConfig = (imported) => {
 	const config = imported?.default ?? imported;
-	if (!config || typeof config !== "object" || !config.prisma) return;
+	if (!config || typeof config !== "object") return;
 	configureArkormRuntime(config.prisma, {
+		adapter: config.adapter,
+		boot: config.boot,
 		pagination: config.pagination,
 		paths: config.paths,
 		outputExt: config.outputExt
@@ -2072,6 +2101,40 @@ var CliApp = class {
 		lines.splice(insertionIndex, 0, `import type { ${enumTypes.join(", ")} } from '@prisma/client'`);
 		return lines.join("\n");
 	}
+	parseModelSyncSource(modelSource) {
+		const classMatch = modelSource.match(/export\s+class\s+(\w+)\s+extends\s+Model(?:<[^\n]+>)?\s*\{/);
+		if (!classMatch) return null;
+		const className = classMatch[1];
+		const tableMatch = modelSource.match(/protected\s+static\s+override\s+table\s*=\s*['"]([^'"]+)['"]/) ?? modelSource.match(/static\s+table\s*=\s*['"]([^'"]+)['"]/);
+		const delegateMatch = modelSource.match(/protected\s+static\s+override\s+delegate\s*=\s*['"]([^'"]+)['"]/) ?? modelSource.match(/static\s+delegate\s*=\s*['"]([^'"]+)['"]/);
+		return {
+			className,
+			table: tableMatch?.[1] ?? delegateMatch?.[1] ?? str(className).camel().plural().toString()
+		};
+	}
+	syncModelFiles(modelFiles, resolveStructure, enums) {
+		const updated = [];
+		const skipped = [];
+		modelFiles.forEach((filePath) => {
+			const source = readFileSync$1(filePath, "utf-8");
+			const structure = resolveStructure(filePath, source);
+			if (!structure || structure.fields.length === 0) {
+				skipped.push(filePath);
+				return;
+			}
+			const synced = this.syncModelDeclarations(source, structure.fields, enums);
+			if (!synced.updated) {
+				skipped.push(filePath);
+				return;
+			}
+			writeFileSync$1(filePath, synced.content);
+			updated.push(filePath);
+		});
+		return {
+			updated,
+			skipped
+		};
+	}
 	/**
 	* Parse Prisma enum definitions from a schema and return their member names.
 	*
@@ -2164,7 +2227,7 @@ var CliApp = class {
 	*/
 	syncModelDeclarations(modelSource, declarations, enums) {
 		const lines = modelSource.split("\n");
-		const classIndex = lines.findIndex((line) => /export\s+class\s+\w+\s+extends\s+Model<.+>\s*\{/.test(line));
+		const classIndex = lines.findIndex((line) => /export\s+class\s+\w+\s+extends\s+Model(?:<[^\n]+>)?\s*\{/.test(line));
 		if (classIndex < 0) return {
 			content: modelSource,
 			updated: false
@@ -2218,6 +2281,36 @@ var CliApp = class {
 			updated: contentWithImports !== modelSource
 		};
 	}
+	async syncModels(options = {}) {
+		const modelsDir = options.modelsDir ?? this.resolveConfigPath("models", join$1(process.cwd(), "src", "models"));
+		if (!existsSync$1(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
+		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts")).map((file) => join$1(modelsDir, file));
+		const adapter = this.getConfig("adapter");
+		if (adapter && typeof adapter.introspectModels === "function") {
+			const sources = modelFiles.reduce((all, filePath) => {
+				const parsed = this.parseModelSyncSource(readFileSync$1(filePath, "utf-8"));
+				if (parsed) all.set(filePath, parsed);
+				return all;
+			}, /* @__PURE__ */ new Map());
+			const discovered = await adapter.introspectModels({ tables: [...new Set([...sources.values()].map((source) => source.table))] });
+			const structuresByTable = new Map(discovered.map((model) => [model.table, model]));
+			const result = this.syncModelFiles(modelFiles, (filePath) => {
+				const parsed = sources.get(filePath);
+				return parsed ? structuresByTable.get(parsed.table) : void 0;
+			}, /* @__PURE__ */ new Map());
+			return {
+				source: "adapter",
+				modelsDir,
+				total: modelFiles.length,
+				updated: result.updated,
+				skipped: result.skipped
+			};
+		}
+		return {
+			source: "prisma",
+			...this.syncModelsFromPrisma(options)
+		};
+	}
 	/**
 	* Sync model attribute declarations in model files based on the Prisma schema.
 	* This method reads the Prisma schema to extract model definitions and their 
@@ -2237,38 +2330,18 @@ var CliApp = class {
 		const schema = readFileSync$1(schemaPath, "utf-8");
 		const prismaEnums = this.parsePrismaEnums(schema);
 		const prismaModels = this.parsePrismaModels(schema);
-		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts"));
-		const updated = [];
-		const skipped = [];
-		modelFiles.forEach((file) => {
-			const filePath = join$1(modelsDir, file);
-			const source = readFileSync$1(filePath, "utf-8");
-			const classMatch = source.match(/export\s+class\s+(\w+)\s+extends\s+Model<'([^']+)'>/);
-			if (!classMatch) {
-				skipped.push(filePath);
-				return;
-			}
-			const className = classMatch[1];
-			const delegate = classMatch[2];
-			const prismaModel = prismaModels.find((model) => model.table === delegate) ?? prismaModels.find((model) => model.name === className);
-			if (!prismaModel || prismaModel.fields.length === 0) {
-				skipped.push(filePath);
-				return;
-			}
-			const synced = this.syncModelDeclarations(source, prismaModel.fields, prismaEnums);
-			if (!synced.updated) {
-				skipped.push(filePath);
-				return;
-			}
-			writeFileSync$1(filePath, synced.content);
-			updated.push(filePath);
-		});
+		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts")).map((file) => join$1(modelsDir, file));
+		const result = this.syncModelFiles(modelFiles, (filePath, source) => {
+			const parsed = this.parseModelSyncSource(source);
+			if (!parsed) return void 0;
+			return prismaModels.find((model) => model.table === parsed.table) ?? prismaModels.find((model) => model.name === parsed.className);
+		}, prismaEnums);
 		return {
 			schemaPath,
 			modelsDir,
 			total: modelFiles.length,
-			updated,
-			skipped
+			updated: result.updated,
+			skipped: result.skipped
 		};
 	}
 };
@@ -2846,20 +2919,21 @@ var MigrationHistoryCommand = class extends Command {
 //#region src/cli/commands/ModelsSyncCommand.ts
 var ModelsSyncCommand = class extends Command {
 	signature = `models:sync
-        {--schema= : Path to prisma schema file}
+        {--schema= : Path to prisma schema file used when adapter introspection is unavailable}
         {--models= : Path to models directory}
     `;
-	description = "Sync model declare attributes from prisma schema for all model files";
+	description = "Sync model declare attributes from the active adapter when supported, otherwise fall back to the Prisma schema";
 	async handle() {
 		this.app.command = this;
-		const result = this.app.syncModelsFromPrisma({
+		const result = await this.app.syncModels({
 			schemaPath: this.option("schema") ? resolve(String(this.option("schema"))) : void 0,
 			modelsDir: this.option("models") ? resolve(String(this.option("models"))) : void 0
 		});
 		const updatedLines = result.updated.length === 0 ? [this.app.splitLogger("Updated", "none")] : result.updated.map((path) => this.app.splitLogger("Updated", path));
 		this.success("SUCCESS: Model sync completed with the following results:");
 		[
-			this.app.splitLogger("Schema", result.schemaPath),
+			this.app.splitLogger("Source", result.source === "adapter" ? "adapter introspection" : "prisma schema"),
+			...result.schemaPath ? [this.app.splitLogger("Schema", result.schemaPath)] : [],
 			this.app.splitLogger("Models", result.modelsDir),
 			this.app.splitLogger("Processed", String(result.total)),
 			...updatedLines,