@flowblade/sqlduck 0.36.1 → 0.36.3

package/README.md

@@ -2,20 +2,18 @@
 
 > Currently experimental
 
-
 - 🛡️ DuckDB table creation from Zod schemas.
 - 🧩 Easily ingest data from generators or async iterables.
 
-
 ## Quick start
 
 ### Create a database connection
 
 ```typescript
-import { DuckDBInstance } from '@duckdb/node-api';
+import { DuckDBInstance } from "@duckdb/node-api";
 DuckDBInstance.create(undefined, {
-   access_mode: 'READ_WRITE',
-   max_memory: '512M',
+  access_mode: "READ_WRITE",
+  max_memory: "512M",
 });
 export const conn = await instance.connect();
 ```
@@ -29,50 +27,48 @@ import { conn } from "./db.config.ts";
 
 const dbManager = new DuckDatabaseManager(conn);
 const database = await dbManager.attach({
-    type: 'memory', // can be 'filesystem', ...
-    alias: 'mydb',
-    options: { COMPRESS: 'false' },
+  type: "memory", // can be 'filesystem', ...
+  alias: "mydb",
+  options: { COMPRESS: "false" },
 });
 
 const sqlDuck = new SqlDuck({ conn });
 
 // Define a zod schema, it will be used to create the table
 const userSchema = z.object({
-    id: z.int32().min(1).meta({ primaryKey: true }),
-    name: z.string(),
+  id: z.int32().min(1).meta({ primaryKey: true }),
+  name: z.string(),
 });
 
 // Example of a datasource (can be generator, async generator, async iterable)
-async function* getUsers(): AsyncIterableIterator<
-    z.infer<typeof userSchema>
-> {
-    // database or api call
-    yield { id: 1, name: 'John' };
-    yield { id: 2, name: 'Jane' };
+async function* getUsers(): AsyncIterableIterator<z.infer<typeof userSchema>> {
+  // database or api call
+  yield { id: 1, name: "John" };
+  yield { id: 2, name: "Jane" };
 }
 
 // Create a table from the schema and the datasource
 const result = await sqlDuck.toTable({
-    table: new Table({ name: 'user', database: database.alias }),
-    schema: userSchema, // The schema to use to create the table
-    rowStream: getUsers(), // The async iterable that yields rows
-    // 👇Optional:
-    chunkSize: 2048, // Number of rows to append when using duckdb appender. Default is 2048
-    onChunkAppended: ({ timeMs, totalRows, rowsPerSecond }) => {
-        console.log(
-            `Appended ${totalRows} in time ${timeMs}ms, est: ${rowsPerSecond} rows/s`
-        );
-    },
-    // Optional table creation options
-    createOptions: {
-        create: 'CREATE_OR_REPLACE',
-    },
+  table: new Table({ name: "user", database: database.alias }),
+  schema: userSchema, // The schema to use to create the table
+  rowStream: getUsers(), // The async iterable that yields rows
+  // 👇Optional:
+  chunkSize: 2048, // Number of rows to append when using duckdb appender. Default is 2048
+  onChunkAppended: ({ timeMs, totalRows, rowsPerSecond }) => {
+    console.log(
+      `Appended ${totalRows} in time ${timeMs}ms, est: ${rowsPerSecond} rows/s`
+    );
+  },
+  // Optional table creation options
+  createOptions: {
+    create: "CREATE_OR_REPLACE",
+  },
 });
 
 console.log(`Inserted ${result.totalRows} rows in ${result.timeMs}ms`);
 console.log(`Table created with DDL: ${result.createTableDDL}`);
 
-const reader = await conn.runAndReadAll('select * from mydb.user');
+const reader = await conn.runAndReadAll("select * from mydb.user");
 const rows = reader.getRowObjectsJS();
 // [{id: 1, name: 'John'}, {id: 2, name: 'Jane'}]]
 ```

package/dist/{file-system-utils-DT6smf4C.mjs → file-system-utils-C7A41ZM2.mjs}

@@ -18,11 +18,21 @@ var FileSystemUtils = class {
 	*
 	* @throws Error if it can't be created
 	*/
-	createDirectory = (path) => {
+	createDirectory = (path, recursive = true) => {
 		try {
-			fs.mkdirSync(path, { recursive: true });
+			fs.mkdirSync(path, { recursive });
+			this.#logger.debug(`Successfully created directory '${path}'`, {
+				path,
+				recursive: true
+			});
 		} catch (err) {
-			if (err.code !== "EEXIST") throw err;
+			if (err.code !== "EEXIST") {
+				this.#logger.warning(`Couldn't create directory '${path}': ${err}.message`, {
+					path,
+					recursive: true
+				});
+				throw err;
+			}
 		}
 	};
 	/**
@@ -86,7 +96,7 @@ var FileSystemUtils = class {
 	*/
 	isSamePath = (path1, path2) => {
 		if (typeof path1 !== "string" || typeof path2 !== "string" || path1.trim().length === 0 || path2.trim().length === 0) return false;
-		return path.resolve(path1) == path.resolve(path2);
+		return path.resolve(path1) === path.resolve(path2);
 	};
 	/**
 	* Check whether two paths (file, directory...) exists and are identical by comparing their real paths.

package/dist/filesystem/index.d.mts

@@ -10,7 +10,7 @@ declare class FileSystemUtils {
    *
    * @throws Error if it can't be created
    */
-  createDirectory: (path: string) => void;
+  createDirectory: (path: string, recursive?: boolean) => void;
   /**
    * Create a directory recursively if it doesn't exist and ensure it's writable
    */

package/dist/filesystem/index.mjs

@@ -1,2 +1,2 @@
-import { t as FileSystemUtils } from "../file-system-utils-DT6smf4C.mjs";
+import { t as FileSystemUtils } from "../file-system-utils-C7A41ZM2.mjs";
 export { FileSystemUtils };

package/dist/{index-Z9LfGsCV.d.mts → index-BSjZdjW_.d.mts}

@@ -8,9 +8,9 @@ declare const duckAllConnectionOptionsZodSchema: z.ZodObject<{
   compress: z.ZodOptional<z.ZodBoolean>;
   type: z.ZodOptional<z.ZodEnum<{
     DUCKDB: "DUCKDB";
-    SQLITE: "SQLITE";
     MYSQL: "MYSQL";
     PostgreSQL: "PostgreSQL";
+    SQLITE: "SQLITE";
   }>>;
   blockSize: z.ZodOptional<z.ZodInt32>;
   rowGroupSize: z.ZodOptional<z.ZodInt32>;
@@ -36,9 +36,9 @@ declare const duckConnectionParamsZodSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     compress: z.ZodOptional<z.ZodBoolean>;
     type: z.ZodOptional<z.ZodEnum<{
       DUCKDB: "DUCKDB";
-      SQLITE: "SQLITE";
       MYSQL: "MYSQL";
       PostgreSQL: "PostgreSQL";
+      SQLITE: "SQLITE";
     }>>;
     blockSize: z.ZodOptional<z.ZodInt32>;
     rowGroupSize: z.ZodOptional<z.ZodInt32>;
@@ -65,9 +65,9 @@ declare const duckConnectionParamsZodSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     compress: z.ZodOptional<z.ZodBoolean>;
     type: z.ZodOptional<z.ZodEnum<{
       DUCKDB: "DUCKDB";
-      SQLITE: "SQLITE";
       MYSQL: "MYSQL";
       PostgreSQL: "PostgreSQL";
+      SQLITE: "SQLITE";
     }>>;
     blockSize: z.ZodOptional<z.ZodInt32>;
     rowGroupSize: z.ZodOptional<z.ZodInt32>;
@@ -103,7 +103,7 @@ declare const duckDsnZodSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<
   options?: {
     accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
     compress?: boolean | undefined;
-    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
+    type?: "DUCKDB" | "MYSQL" | "PostgreSQL" | "SQLITE" | undefined;
     blockSize?: number | undefined;
     rowGroupSize?: number | undefined;
     storageVersion?: string | undefined;
@@ -118,7 +118,7 @@ declare const duckDsnZodSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<
   options?: {
     accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
     compress?: boolean | undefined;
-    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
+    type?: "DUCKDB" | "MYSQL" | "PostgreSQL" | "SQLITE" | undefined;
     blockSize?: number | undefined;
     rowGroupSize?: number | undefined;
     storageVersion?: string | undefined;
@@ -137,9 +137,9 @@ declare const duckDsnZodSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<
     compress: z.ZodOptional<z.ZodBoolean>;
     type: z.ZodOptional<z.ZodEnum<{
       DUCKDB: "DUCKDB";
-      SQLITE: "SQLITE";
       MYSQL: "MYSQL";
       PostgreSQL: "PostgreSQL";
+      SQLITE: "SQLITE";
     }>>;
     blockSize: z.ZodOptional<z.ZodInt32>;
     rowGroupSize: z.ZodOptional<z.ZodInt32>;
@@ -166,9 +166,9 @@ declare const duckDsnZodSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<
     compress: z.ZodOptional<z.ZodBoolean>;
     type: z.ZodOptional<z.ZodEnum<{
       DUCKDB: "DUCKDB";
-      SQLITE: "SQLITE";
       MYSQL: "MYSQL";
       PostgreSQL: "PostgreSQL";
+      SQLITE: "SQLITE";
     }>>;
     blockSize: z.ZodOptional<z.ZodInt32>;
     rowGroupSize: z.ZodOptional<z.ZodInt32>;
@@ -208,7 +208,7 @@ declare const duckValidatorsZod: {
 };
 //#endregion
 //#region src/validation/zod/ensure-zod-table-schema.d.ts
-type TObject = Record<string, string | number | null | undefined | boolean | Date>;
+type TObject = Record<string, string | number | null | undefined | boolean | Date | (string | number | null | boolean)[]>;
 declare const EXPLICIT_GENERIC_REQUIRED: unique symbol;
 type RequireExplicitGeneric = TObject & {
   [EXPLICIT_GENERIC_REQUIRED]: never;
@@ -247,12 +247,12 @@ type RequireExplicitGeneric = TObject & {
 declare const ensureZodTableSchema: <T extends TObject = RequireExplicitGeneric>(schema: z.ZodObject<{ [K in keyof NoInfer<T>]-?: z.ZodType<NoInfer<T>[K]>; }>) => z.ZodObject<{ [K in keyof NoInfer<T>]-?: z.ZodType<NoInfer<T>[K], unknown, z.core.$ZodTypeInternals<NoInfer<T>[K], unknown>>; }, z.core.$strip>;
 //#endregion
 //#region src/validation/zod/infer-zod-relaxed-data-schema.d.ts
-type MapRelaxedZodSchemaField<T extends z.ZodTypeAny> = T extends z.ZodDate ? string | Date : T extends z.ZodISODate ? string | Date : T extends z.ZodOptional<any> ? MapRelaxedZodSchemaField<T['_def']['innerType']> | undefined : T extends z.ZodNullable<any> ? MapRelaxedZodSchemaField<T['_def']['innerType']> | null : z.infer<T>;
+type MapRelaxedZodSchemaField<T extends z.ZodTypeAny> = T extends z.ZodDate ? string | Date : T extends z.ZodISODate ? string | Date : T extends z.ZodOptional<any> ? MapRelaxedZodSchemaField<T["_def"]["innerType"]> | undefined : T extends z.ZodNullable<any> ? MapRelaxedZodSchemaField<T["_def"]["innerType"]> | null : z.infer<T>;
 /**
  * Add string type to all Date properties so it makes it an union between
  * Date | string
  */
-type InferZodRelaxedDataSchema<T extends z.ZodObject<any>> = { [K in keyof T['shape']]: MapRelaxedZodSchemaField<T['shape'][K]>; };
+type InferZodRelaxedDataSchema<T extends z.ZodObject<any>> = { [K in keyof T["shape"]]: MapRelaxedZodSchemaField<T["shape"][K]>; };
 //#endregion
 //#region src/validation/zod/table-schema-zod.d.ts
 type ZodSchemaSupportedTypes = z.ZodString | z.ZodNumber | z.ZodInt | z.ZodInt32 | z.ZodUInt32 | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodISODateTime | z.ZodISOTime | z.ZodISODate | z.ZodEmail | z.ZodURL | z.ZodUUID | z.ZodCUID | z.ZodCUID2 | z.ZodULID | z.ZodEnum | z.ZodArray;

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { l as DuckConnectionParams, n as InferZodRelaxedDataSchema, t as TableSchemaZod } from "./index-Z9LfGsCV.mjs";
+import { l as DuckConnectionParams, n as InferZodRelaxedDataSchema, t as TableSchemaZod } from "./index-BSjZdjW_.mjs";
 import { DuckDBConnection, DuckDBDecimalType, DuckDBListType, DuckDBType } from "@duckdb/node-api";
 import { Logger } from "@logtape/logtape";
 import * as z from "zod";
@@ -79,12 +79,12 @@ declare class Table {
 //#endregion
 //#region src/table/get-table-create-from-zod.d.ts
 type TableCreateOptions = {
-  create?: 'CREATE' | 'CREATE_OR_REPLACE' | 'IF_NOT_EXISTS';
+  create?: "CREATE" | "CREATE_OR_REPLACE" | "IF_NOT_EXISTS";
 };
 type DuckdbColumnTypeMap<TKeys extends string> = Map<TKeys, DuckDBType>;
 type TableCreateFromZodResult<TSchema extends TableSchemaZod> = {
   ddl: string;
-  columnTypes: DuckdbColumnTypeMap<Exclude<keyof TSchema['shape'], symbol | number>>;
+  columnTypes: DuckdbColumnTypeMap<Exclude<keyof TSchema["shape"], symbol | number>>;
 };
 type GetTableCreateFromZodParams<TSchema extends TableSchemaZod> = {
   table: Table;
@@ -279,7 +279,7 @@ declare const duckDatabaseManagerZodSchemas: {
 //#region src/manager/database/duck-database-manager.d.ts
 type GetDatabaseInfo = z.infer<typeof duckDatabaseManagerZodSchemas.getDatabases>;
 type AttachOptions = {
-  behaviour: 'OR REPLACE';
+  behaviour: "OR REPLACE";
   /**
    * Since duckdb 1.5.4, the ATTACH OR REPLACE fails if the database is already attached.
    * If this option is set to true, when an attachOrReplace fails with the already attached
@@ -291,7 +291,7 @@ type AttachOptions = {
    */
   runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
 } | {
-  behaviour: 'IF NOT EXISTS';
+  behaviour: "IF NOT EXISTS";
 };
 declare class DuckDatabaseManager {
   #private;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as sqlduckDefaultLogtapeLogger, r as flowbladeLogtapeSqlduckConfig, t as FileSystemUtils } from "./file-system-utils-DT6smf4C.mjs";
+import { n as sqlduckDefaultLogtapeLogger, r as flowbladeLogtapeSqlduckConfig, t as FileSystemUtils } from "./file-system-utils-C7A41ZM2.mjs";
 import { t as duckReservedKeywords } from "./duck-reserved-keywords-BzYA7jvN.mjs";
 import { c as duckValidatorsZod, r as assertValidAliasName, s as duckConnectionParamsZodSchema } from "./zod-DB5FHzXW.mjs";
 import { BIGINT, BOOLEAN, DATE, DECIMAL, DOUBLE, DuckDBDataChunk, DuckDBDateValue, DuckDBDecimalType, DuckDBDecimalValue, DuckDBInstanceCache, DuckDBListType, DuckDBTimestampMillisecondsValue, DuckDBTypeId, ENUM, FLOAT, HUGEINT, INTEGER, LIST, SMALLINT, TIMESTAMP, TIMESTAMP_MS, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR, listValue } from "@duckdb/node-api";
@@ -69,14 +69,14 @@ var DuckMemory = class {
 		const { orderBy } = params ?? {};
 		const query = this.#applyOrderBy(`SELECT tag, memory_usage_bytes, temporary_storage_bytes 
              FROM duckdb_memory() as m`, orderBy);
-		return (await this.#conn.run(query)).getRowObjectsJS();
+		return await (await this.#conn.run(query)).getRowObjectsJS();
 	};
 	getByTag = async (tag) => {
 		if (!duckMemoryTags.includes(tag)) throw new Error(`Invalid DuckDB memory tag: ${tag}`);
 		const query = `SELECT tag, memory_usage_bytes, temporary_storage_bytes
                    FROM duckdb_memory() as m
                    WHERE tag = '${tag}'`;
-		return this.#exec.getOneRowObjectJS(query);
+		return await this.#exec.getOneRowObjectJS(query);
 	};
 	getSummary = async () => {
 		const rows = await this.getAll();
@@ -483,13 +483,13 @@ var DuckDatabaseManager = class {
 	* ```
 	*/
 	attachOrReplace = async (dbParams, options) => {
-		return this.attach(dbParams, {
+		return await this.attach(dbParams, {
 			behaviour: "OR REPLACE",
 			runDetachIfAttachOrReplaceFailWithAlreadyAttached: options?.runDetachIfAttachOrReplaceFailWithAlreadyAttached
 		});
 	};
 	attachIfNotExists = async (dbParams) => {
-		return this.attach(dbParams, { behaviour: "IF NOT EXISTS" });
+		return await this.attach(dbParams, { behaviour: "IF NOT EXISTS" });
 	};
 	/**
 	* Check whether a specific database name / alias is currently attached
@@ -536,7 +536,7 @@ var DuckDatabaseManager = class {
 	getDatabases = async (params) => {
 		const { includeInternal = false } = params ?? {};
 		const internalFilter = includeInternal ? "1=1" : "internal = false";
-		return this.#executor.getRowObjectsJS("getDatabases", `select database_name,
+		return await this.#executor.getRowObjectsJS("getDatabases", `select database_name,
                      database_oid,
                      path,
                      comment,
@@ -639,7 +639,7 @@ var DuckDatabaseManager = class {
 		return { status: "created" };
 	};
 	#getFs = () => {
-		if (this.#fs === void 0) this.#fs = new FileSystemUtils({ logger: this.#logger });
+		this.#fs ??= new FileSystemUtils({ logger: this.#logger });
 		return this.#fs;
 	};
 };
@@ -1016,7 +1016,7 @@ var SqlDuck = class {
 			const isAsyncCb = onChunkAppended !== void 0 && isOnChunkAppendedAsyncCb(onChunkAppended);
 			for await (const dataChunk of columnStream) {
 				const chunk = DuckDBDataChunk.create(chunkTypes);
-				const columns = new Array(numColumns);
+				const columns = Array.from({ length: numColumns });
 				for (let i = 0; i < numColumns; i++) columns[i] = dataChunk[columnKeys[i]];
 				totalRows += columns[0]?.length ?? 0;
 				chunk.setColumns(columns);

package/dist/integrations/kysely/index.d.mts

@@ -7,7 +7,7 @@ type SqlTagInformation = {
 declare const compileDuckQuery: <T extends SelectQueryBuilder<any, any, any>>(query: T) => SqlTagInformation;
 //#endregion
 //#region src/integrations/kysely/create-duck-kysely-query-builder.d.ts
-type KyselyQueryBuilder<TDatabase> = Pick<Kysely<TDatabase>, 'mergeInto' | 'selectFrom' | 'selectNoFrom' | 'deleteFrom' | 'updateTable' | 'insertInto' | 'replaceInto' | 'with' | 'withRecursive' | 'withTables'>;
+type KyselyQueryBuilder<TDatabase> = Pick<Kysely<TDatabase>, "mergeInto" | "selectFrom" | "selectNoFrom" | "deleteFrom" | "updateTable" | "insertInto" | "replaceInto" | "with" | "withRecursive" | "withTables">;
 declare const createDuckKysekyQueryBuilder: <TDatabase>(params?: {
   schema?: string;
 }) => KyselyQueryBuilder<TDatabase>;

package/dist/validation/valibot/index.d.mts

@@ -50,7 +50,7 @@ declare const duckDsnValibotSchema: v.SchemaWithPipe<readonly [v.StringSchema<un
   options?: {
     accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
     compress?: boolean | undefined;
-    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
+    type?: "DUCKDB" | "MYSQL" | "PostgreSQL" | "SQLITE" | undefined;
     blockSize?: number | undefined;
     rowGroupSize?: number | undefined;
     storageVersion?: string | undefined;
@@ -65,7 +65,7 @@ declare const duckDsnValibotSchema: v.SchemaWithPipe<readonly [v.StringSchema<un
   options?: {
     accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
     compress?: boolean | undefined;
-    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
+    type?: "DUCKDB" | "MYSQL" | "PostgreSQL" | "SQLITE" | undefined;
     blockSize?: number | undefined;
     rowGroupSize?: number | undefined;
     storageVersion?: string | undefined;

package/dist/validation/zod/index.d.mts

@@ -1,2 +1,2 @@
-import { a as duckDsnZodSchema, c as assertValidTableName, d as duckConnectionParamsZodSchema, i as duckValidatorsZod, n as InferZodRelaxedDataSchema, o as assertValidAliasName, r as ensureZodTableSchema, s as assertValidSchemaName, t as TableSchemaZod, u as duckAllConnectionOptionsZodSchema } from "../../index-Z9LfGsCV.mjs";
+import { a as duckDsnZodSchema, c as assertValidTableName, d as duckConnectionParamsZodSchema, i as duckValidatorsZod, n as InferZodRelaxedDataSchema, o as assertValidAliasName, r as ensureZodTableSchema, s as assertValidSchemaName, t as TableSchemaZod, u as duckAllConnectionOptionsZodSchema } from "../../index-BSjZdjW_.mjs";
 export { type InferZodRelaxedDataSchema, type TableSchemaZod, assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckDsnZodSchema, duckValidatorsZod, ensureZodTableSchema };

package/package.json

@@ -1,41 +1,56 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.36.1",
+  "version": "0.36.3",
+  "homepage": "https://github.com/belgattitude/flowblade",
+  "license": "MIT",
+  "author": {
+    "name": "Vanvelthem Sébastien",
+    "url": "https://github.com/belgattitude"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/belgattitude/flowblade.git",
+    "directory": "packages/sqlduck"
+  },
+  "files": [
+    "dist"
+  ],
   "type": "module",
   "sideEffects": false,
+  "imports": {
+    "#/tests/data/*": "./tests/data/*",
+    "#/tests/utils/*": "./tests/utils/*"
+  },
   "exports": {
     ".": {
+      "flowblade-monorepo-source": "./src/index.ts",
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
     },
     "./filesystem": {
+      "flowblade-monorepo-source": "./src/filesystem/index.ts",
       "types": "./dist/filesystem/index.d.mts",
       "default": "./dist/filesystem/index.mjs"
     },
     "./zod": {
+      "flowblade-monorepo-source": "./src/zod/index.ts",
       "types": "./dist/validation/zod/index.d.mts",
       "default": "./dist/validation/zod/index.mjs"
     },
     "./valibot": {
+      "flowblade-monorepo-source": "./src/valibot/index.ts",
       "types": "./dist/validation/valibot/index.d.mts",
       "default": "./dist/validation/valibot/index.mjs"
     },
     "./kysely": {
+      "flowblade-monorepo-source": "./src/kysely/index.ts",
       "types": "./dist/integrations/kysely/index.d.mts",
       "default": "./dist/integrations/kysely/index.mjs"
     },
     "./package.json": "./package.json"
   },
-  "author": {
-    "name": "Vanvelthem Sébastien",
-    "url": "https://github.com/belgattitude"
-  },
-  "license": "MIT",
-  "homepage": "https://github.com/belgattitude/flowblade",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/belgattitude/flowblade.git",
-    "directory": "packages/sqlduck"
+  "publishConfig": {
+    "directory": "_release/package"
   },
   "scripts": {
     "clean": "rimraf ./dist ./coverage ./tsconfig.tsbuildinfo",
@@ -58,12 +73,14 @@
     "test-e2e": "vitest -c vitest.e2e.config.ts run",
     "test-e2e-bun": "bun --bun run vitest -c vitest.e2e.config.ts run",
     "test-e2e-watch": "vitest -c vitest.e2e.config.ts --ui",
-    "typecheck": "tsgo --project tsconfig.json --noEmit",
-    "lint": "eslint . --ext .ts,.tsx,.js,.jsx,.mjs,.cjs,.mts,.cts --cache --cache-location ../../../.cache/eslint/sqlduck.eslintcache",
-    "fix-staged": "lint-staged --allow-empty",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "lint": "ultracite check",
+    "lint-fix": "ultracite fix",
     "check-dist": "es-check --config=.escheckrc.json",
     "check-pub": "publint",
-    "check-size-disabled": "size-limit"
+    "check-size-disabled": "size-limit",
+    "check": "ultracite check",
+    "fix": "ultracite fix"
   },
   "dependencies": {
     "@flowblade/core": "^0.2.29",
@@ -78,21 +95,7 @@
     "p-queue": "^9.3.3",
     "zod": "^4.4.3"
   },
-  "peerDependencies": {
-    "@duckdb/node-api": "^1.5.3-r.2",
-    "kysely": "^0.29.0",
-    "valibot": "^1.3.1"
-  },
-  "peerDependenciesMeta": {
-    "kysely": {
-      "optional": true
-    },
-    "valibot": {
-      "optional": true
-    }
-  },
   "devDependencies": {
-    "@belgattitude/eslint-config-bases": "8.19.1",
     "@dotenvx/dotenvx": "2.21.0",
     "@duckdb/node-api": "1.5.5-r.4",
     "@faker-js/faker": "10.6.0",
@@ -104,9 +107,6 @@
     "@testcontainers/mssqlserver": "12.1.0",
     "@total-typescript/ts-reset": "0.6.1",
     "@types/node": "26.2.0",
-    "@typescript-eslint/eslint-plugin": "8.67.0",
-    "@typescript-eslint/parser": "8.67.0",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "@vitest/coverage-v8": "4.1.11",
     "@vitest/ui": "4.1.11",
     "ansis": "4.3.1",
@@ -114,15 +114,17 @@
     "core-js": "3.50.0",
     "cross-env": "10.1.0",
     "es-check": "9.6.4",
-    "es-toolkit": "1.50.0",
+    "es-toolkit": "1.51.0",
     "esbuild": "0.28.2",
-    "eslint": "8.57.1",
+    "eslint-plugin-sonarjs": "^4.2.0",
     "execa": "10.0.1",
     "is-in-ci": "2.0.0",
     "kysely": "0.29.5",
     "mitata": "1.0.34",
     "npm-run-all2": "9.0.3",
-    "prettier": "3.9.6",
+    "oxfmt": "0.64.0",
+    "oxlint": "1.79.0",
+    "oxlint-tsgolint": "7.0.2001",
     "publint": "0.3.23",
     "regexp.escape": "2.0.1",
     "rimraf": "6.1.3",
@@ -135,14 +137,22 @@
     "tsx": "4.23.12",
     "typedoc": "0.28.20",
     "typedoc-plugin-markdown": "4.12.0",
-    "typescript": "6.0.3",
+    "typescript": "7.0.2",
+    "ultracite": "7.10.6",
     "valibot": "1.4.2",
     "vitest": "4.1.11"
   },
-  "files": [
-    "dist"
-  ],
-  "publishConfig": {
-    "directory": "_release/package"
+  "peerDependencies": {
+    "@duckdb/node-api": "^1.5.3-r.2",
+    "kysely": "^0.29.0",
+    "valibot": "^1.3.1"
+  },
+  "peerDependenciesMeta": {
+    "kysely": {
+      "optional": true
+    },
+    "valibot": {
+      "optional": true
+    }
   }
 }