@fragno-dev/db 0.3.0 → 0.4.1

package/src/schema-output/prisma.ts

@@ -1,17 +1,18 @@
-import { parseVarchar } from "../util/parse";
-import type { AnyColumn, AnySchema, AnyTable, Relation } from "../schema/create";
 import {
   defaultNamingStrategyForDatabase,
   type SupportedDatabase,
 } from "../adapters/generic-sql/driver-config";
 import type { SQLiteStorageMode } from "../adapters/generic-sql/sqlite-storage";
 import { sqliteStorageDefault, sqliteStoragePrisma } from "../adapters/generic-sql/sqlite-storage";
+import { internalSchema } from "../fragments/internal-fragment.schema";
 import {
   sanitizeNamespace,
   createNamingResolver,
   type NamingResolver,
   type SqlNamingStrategy,
 } from "../naming/sql-naming";
+import type { AnyColumn, AnySchema, AnyTable, Relation } from "../schema/create";
+import { parseVarchar } from "../util/parse";
 
 export interface GeneratePrismaSchemaOptions {
   sqliteStorageMode?: SQLiteStorageMode;
@@ -269,6 +270,9 @@ function areInverseRelations(one: Relation, many: Relation): boolean {
   if (one.type !== "one" || many.type !== "many") {
     return false;
   }
+  if (one.foreignKey === false || many.foreignKey === false) {
+    return false;
+  }
   if (one.referencer !== many.table || one.table !== many.referencer) {
     return false;
   }
@@ -282,6 +286,9 @@ function findMatchingManyRelation(one: Relation): Relation | undefined {
     if (relation.type !== "many") {
       continue;
     }
+    if (relation.foreignKey === false) {
+      continue;
+    }
     if (areInverseRelations(one, relation)) {
       return relation;
     }
@@ -294,6 +301,9 @@ function findMatchingOneRelation(many: Relation): Relation | undefined {
     if (relation.type !== "one") {
       continue;
     }
+    if (relation.foreignKey === false) {
+      continue;
+    }
     if (areInverseRelations(relation, many)) {
       return relation;
     }
@@ -365,6 +375,9 @@ function generateRelationFields(
     if (relation.type !== "one") {
       continue;
     }
+    if (relation.foreignKey === false) {
+      continue;
+    }
 
     const fieldName = getRelationFieldName(relation.name, usedNames);
     usedNames.add(fieldName);
@@ -398,6 +411,9 @@ function generateRelationFields(
     if (relation.type !== "many") {
       continue;
     }
+    if (relation.foreignKey === false) {
+      continue;
+    }
 
     const matchingOne = findMatchingOneRelation(relation);
     const relationName = matchingOne
@@ -419,7 +435,7 @@ function generateRelationFields(
   const inverseCandidates: Relation[] = [];
   for (const sourceTable of fieldNameByTableColumn.keys()) {
     for (const rel of Object.values(sourceTable.relations)) {
-      if (rel.type === "one" && rel.table === table) {
+      if (rel.type === "one" && rel.table === table && rel.foreignKey !== false) {
         inverseCandidates.push(rel);
       }
     }
@@ -504,22 +520,26 @@ export function generatePrismaSchema(
     options?.sqliteStorageMode ??
     (provider === "sqlite" ? sqliteStoragePrisma : sqliteStorageDefault);
   const namingStrategy = options?.namingStrategy ?? defaultNamingStrategyForDatabase(provider);
-  const namespaces = Array.from(new Set(fragments.map((fragment) => fragment.namespace)));
-  const sortedNamespaces = namespaces.sort((a, b) => {
-    const aKey = a ?? "";
-    const bKey = b ?? "";
-    if (aKey === "") {
+  const sortedFragments = [...fragments].sort((a, b) => {
+    const aInternal = a.schema === internalSchema;
+    const bInternal = b.schema === internalSchema;
+    if (aInternal) {
       return -1;
     }
-    if (bKey === "") {
+    if (bInternal) {
       return 1;
     }
-    return aKey.localeCompare(bKey);
+    return a.schema.name.localeCompare(b.schema.name);
   });
 
-  const sortedFragments = sortedNamespaces
-    .map((namespace) => fragments.find((fragment) => fragment.namespace === namespace))
-    .filter((fragment): fragment is { namespace: string | null; schema: AnySchema } => !!fragment);
+  const namespaces: Array<string | null> = [];
+  const seenNamespaces = new Set<string | null>();
+  for (const fragment of sortedFragments) {
+    if (!seenNamespaces.has(fragment.namespace)) {
+      seenNamespaces.add(fragment.namespace);
+      namespaces.push(fragment.namespace);
+    }
+  }
 
   const fieldNameByTableColumn = new Map<AnyTable, Map<string, string>>();
   const columnByTableName = new Map<AnyTable, Map<string, AnyColumn>>();
@@ -532,7 +552,7 @@ export function generatePrismaSchema(
     }
   }
 
-  const headerNamespaces = sortedNamespaces.filter(Boolean);
+  const headerNamespaces = namespaces.filter(Boolean);
   const headerSuffix = headerNamespaces.length > 0 ? headerNamespaces.join(", ") : "(internal)";
   const lines: string[] = [
     "// Generated by Fragno Prisma adapter.",

package/src/sql-driver/better-sqlite3.test.ts

@@ -1,9 +1,11 @@
-import SQLite from "better-sqlite3";
 import { describe, expect, it } from "vitest";
-import { SqlDriverAdapter } from "./sql-driver-adapter";
+
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
+
 import type { GenericSQLPlugin } from "./query-executor/plugin";
 import { sql } from "./sql";
-import { SqliteDialect } from "kysely";
+import { SqlDriverAdapter } from "./sql-driver-adapter";
 
 describe("better-sqlite3", () => {
   it("Should be able to execute queries using better-sqlite3", async () => {

package/src/sql-driver/dialects/durable-object-dialect.ts

@@ -111,7 +111,6 @@ export class DurableObjectDialect implements Dialect {
 
 class DurableObjectDriver implements Driver {
   #config: DODialectConfig;
-  #connection: DOConnection | null = null;
 
   constructor(config: DODialectConfig) {
     this.#config = config;
@@ -120,11 +119,7 @@ class DurableObjectDriver implements Driver {
   async init(): Promise<void> {}
 
   async acquireConnection(): Promise<DatabaseConnection> {
-    // Ensure only one connection exists
-    if (!this.#connection) {
-      this.#connection = new DOConnection(this.#config);
-    }
-    return this.#connection;
+    return new DOConnection(this.#config);
   }
 
   async beginTransaction(conn: DOConnection): Promise<void> {
@@ -140,11 +135,11 @@ class DurableObjectDriver implements Driver {
   }
 
   async releaseConnection(_conn: DOConnection): Promise<void> {
-    this.#connection = null;
+    // No-op
   }
 
   async destroy(): Promise<void> {
-    this.#connection = null;
+    // No-op
   }
 }
 

package/src/sql-driver/query-executor/default-query-executor.ts

@@ -7,8 +7,8 @@
  * Simplified to remove query compilation.
  */
 
-import type { DatabaseConnection } from "../sql-driver";
 import type { ConnectionProvider } from "../connection/connection-provider";
+import type { DatabaseConnection } from "../sql-driver";
 import type { GenericSQLPlugin } from "./plugin";
 import { QueryExecutorBase } from "./query-executor-base";
 

package/src/sql-driver/query-executor/query-executor-base.ts

@@ -7,8 +7,8 @@
  * Simplified to remove query compilation, streaming, and batching.
  */
 
-import type { DatabaseConnection, CompiledQuery, QueryResult } from "../sql-driver";
 import type { ConnectionProvider } from "../connection/connection-provider";
+import type { DatabaseConnection, CompiledQuery, QueryResult } from "../sql-driver";
 import type { GenericSQLPlugin } from "./plugin";
 import type { QueryExecutor } from "./query-executor";
 

package/src/sql-driver/query-executor/query-executor.ts

@@ -7,8 +7,8 @@
  * Simplified to remove query compilation, streaming, and batching.
  */
 
-import type { CompiledQuery, QueryResult } from "../sql-driver";
 import type { ConnectionProvider } from "../connection/connection-provider";
+import type { CompiledQuery, QueryResult } from "../sql-driver";
 import type { GenericSQLPlugin } from "./plugin";
 
 /**

package/src/sql-driver/sql-driver-adapter.ts

@@ -5,13 +5,13 @@
  * Copyright (c) 2022 Sami Koskimäki
  */
 
-import type { CompiledQuery, Dialect, QueryResult } from "./sql-driver";
 import { DefaultConnectionProvider } from "./connection/connection-provider";
 import { SingleConnectionProvider } from "./connection/single-connection-provider";
 import { RuntimeDriver } from "./driver/runtime-driver";
+import { DefaultQueryExecutor } from "./query-executor/default-query-executor";
 import type { GenericSQLPlugin } from "./query-executor/plugin";
 import type { QueryExecutor } from "./query-executor/query-executor";
-import { DefaultQueryExecutor } from "./query-executor/default-query-executor";
+import type { CompiledQuery, Dialect, QueryResult } from "./sql-driver";
 
 export class SqlDriverAdapter {
   readonly #dialect: Dialect;

package/src/sql-driver/sql.ts

@@ -1,10 +1,11 @@
-import type { CompiledQuery, Dialect } from "./sql-driver";
 import {
   sql as kyselySql,
   type QueryExecutor,
   type CompiledQuery as KyselyCompiledQuery,
 } from "kysely";
 
+import type { CompiledQuery, Dialect } from "./sql-driver";
+
 /**
  * Wrapper around Kysely's RawBuilder that provides a compile() method with a dialect parameter.
  */

package/src/sql-driver/sqlocal.test.ts

@@ -1,8 +1,10 @@
-import { SQLocalKysely } from "sqlocal/kysely";
 import { describe, expect, it } from "vitest";
-import { SqlDriverAdapter } from "./sql-driver-adapter";
+
+import { SQLocalKysely } from "sqlocal/kysely";
+
 import type { GenericSQLPlugin } from "./query-executor/plugin";
 import { sql } from "./sql";
+import { SqlDriverAdapter } from "./sql-driver-adapter";
 
 describe("SQLocal", () => {
   it("should create a new SQLocal instance", async () => {

package/src/sync/commands.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+
+import { schema, column, idColumn } from "../schema/create";
+import { defineSyncCommands } from "./commands";
+
+const testSchema = schema("sync-test", (s) =>
+  s.addTable("items", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),
+);
+
+describe("defineSyncCommands", () => {
+  it("creates a registry with command map", () => {
+    const registry = defineSyncCommands({ schema: testSchema }).create(({ defineCommand }) => [
+      defineCommand({
+        name: "ping",
+        handler: async () => undefined,
+      }),
+    ]);
+
+    expect(registry.schemaName).toBe("sync-test");
+    expect(registry.commands.size).toBe(1);
+    expect(registry.commands.get("ping")).toBeDefined();
+    expect(registry.getCommand("ping")).toBe(registry.commands.get("ping"));
+  });
+
+  it("throws on duplicate command names", () => {
+    expect(() =>
+      defineSyncCommands({ schema: testSchema }).create(({ defineCommand }) => [
+        defineCommand({
+          name: "dup",
+          handler: async () => undefined,
+        }),
+        defineCommand({
+          name: "dup",
+          handler: async () => undefined,
+        }),
+      ]),
+    ).toThrow(/already defined/i);
+  });
+});

package/src/sync/commands.ts

@@ -0,0 +1,51 @@
+import type { AnySchema } from "../schema/create";
+import type { SyncCommandDefinition, SyncCommandRegistry } from "./types";
+
+type DefineSyncCommandsContext = {
+  defineCommand: <TInput, TContext>(
+    definition: SyncCommandDefinition<TInput, TContext>,
+  ) => SyncCommandDefinition<TInput, TContext>;
+};
+
+const createRegistry = (
+  schemaName: string,
+  commandList: readonly SyncCommandDefinition[],
+): SyncCommandRegistry => {
+  const commands = new Map<string, SyncCommandDefinition>();
+
+  for (const command of commandList) {
+    if (!command || typeof command !== "object") {
+      throw new Error("Sync commands must be objects.");
+    }
+
+    const name = command.name;
+    if (typeof name !== "string" || name.trim().length === 0) {
+      throw new Error("Sync command name must be a non-empty string.");
+    }
+
+    const existing = commands.get(name);
+    if (existing && existing !== command) {
+      throw new Error(`Sync command "${name}" is already defined for schema "${schemaName}".`);
+    }
+
+    commands.set(name, command);
+  }
+
+  return {
+    schemaName,
+    commands,
+    getCommand: (name) => commands.get(name),
+  };
+};
+
+export const defineSyncCommands = <TSchema extends AnySchema>(options: { schema: TSchema }) => {
+  const schemaName = options.schema.name;
+  return {
+    create: <const TCommands extends readonly SyncCommandDefinition[]>(
+      factory: (context: DefineSyncCommandsContext) => TCommands,
+    ): SyncCommandRegistry => {
+      const commands = factory({ defineCommand: (definition) => definition });
+      return createRegistry(schemaName, commands);
+    },
+  };
+};