npm - @pikku/cli - Versions diffs - 0.12.23 → 0.12.25 - Mend

@pikku/cli 0.12.23 → 0.12.25

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 (120) hide show

package/dist/src/functions/commands/emails-init.js ADDED Viewed

@@ -0,0 +1,162 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { generateEmailsArtifacts } from '../wirings/emails/pikku-command-emails.js';
+const DEFAULT_EMAIL_DIR = 'emails';
+const DEFAULT_THEME = {
+    appName: 'Pikku App',
+    previewText: 'Your app can render localized emails out of the box.',
+    colors: {
+        background: '#f5f7fb',
+        surface: '#ffffff',
+        text: '#101828',
+        muted: '#475467',
+        border: '#d0d5dd',
+        primary: '#7c3aed',
+        primaryText: '#ffffff',
+        footer: '#667085',
+    },
+    fonts: {
+        body: "Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    },
+};
+const DEFAULT_EN_LOCALE = {
+    helloWorld: {
+        subject: 'Hello from {{appName}}',
+        eyebrow: 'Email templates are live',
+        title: 'Your first Pikku email is ready',
+        intro: 'This starter template proves the pipeline works and gives you a place to shape your own visual language.',
+        body: 'Chat to your AI to create new emails, refine the theme, or localize every message for your product.',
+        cta: 'Open the email console',
+        footer: 'Built with Pikku email templates.',
+    },
+};
+const DEFAULT_DE_LOCALE = {
+    helloWorld: {
+        subject: 'Hallo von {{appName}}',
+        eyebrow: 'E-Mail-Vorlagen sind aktiv',
+        title: 'Deine erste Pikku-E-Mail ist bereit',
+        intro: 'Diese Startvorlage zeigt, dass die Pipeline funktioniert, und gibt dir einen Ausgangspunkt fuer dein eigenes Design.',
+        body: 'Sprich mit deiner KI, um neue E-Mails zu erstellen, das Theme zu verfeinern oder jede Nachricht zu lokalisieren.',
+        cta: 'E-Mail-Konsole oeffnen',
+        footer: 'Erstellt mit Pikku-E-Mail-Vorlagen.',
+    },
+};
+function layoutTemplate() {
+    return `<!doctype html>
+<html lang="{{locale}}">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{subject}}</title>
+  </head>
+  <body style="margin:0;padding:32px 16px;background:{{theme.colors.background}};font-family:{{theme.fonts.body}};color:{{theme.colors.text}};">
+    <div style="max-width:640px;margin:0 auto;background:{{theme.colors.surface}};border:1px solid {{theme.colors.border}};border-radius:20px;overflow:hidden;">
+      {{content}}
+    </div>
+  </body>
+</html>
+`;
+}
+function footerPartial() {
+    return `<div style="padding:24px 32px;border-top:1px solid {{theme.colors.border}};font-size:13px;line-height:1.6;color:{{theme.colors.footer}};">
+  <p style="margin:0;">{{t.helloWorld.footer}}</p>
+</div>
+`;
+}
+function helloWorldHtml() {
+    return `<div style="padding:32px;">
+  <p style="margin:0 0 16px;font-size:12px;letter-spacing:0.12em;text-transform:uppercase;color:{{theme.colors.primary}};">
+    {{t.helloWorld.eyebrow}}
+  </p>
+  <h1 style="margin:0 0 16px;font-size:32px;line-height:1.15;color:{{theme.colors.text}};">
+    {{t.helloWorld.title}}
+  </h1>
+  <p style="margin:0 0 16px;font-size:16px;line-height:1.7;color:{{theme.colors.muted}};">
+    Hello {{userName}}. {{t.helloWorld.intro}}
+  </p>
+  <p style="margin:0 0 24px;font-size:16px;line-height:1.7;color:{{theme.colors.muted}};">
+    {{t.helloWorld.body}}
+  </p>
+  <a
+    href="{{previewUrl}}"
+    style="display:inline-block;padding:14px 18px;border-radius:999px;background:{{theme.colors.primary}};color:{{theme.colors.primaryText}};font-weight:600;text-decoration:none;"
+  >
+    {{t.helloWorld.cta}}
+  </a>
+</div>
+{{> footer}}
+`;
+}
+function helloWorldSubject() {
+    return `{{t.helloWorld.subject}}
+`;
+}
+function helloWorldText() {
+    return `{{t.helloWorld.title}}
+Hello {{userName}}.
+{{t.helloWorld.intro}}
+{{t.helloWorld.body}}
+{{t.helloWorld.cta}}: {{previewUrl}}
+`;
+}
+async function ensureFile(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, 'utf8');
+}
+async function updateJsonConfig(configDir, emailDir) {
+    const configPath = join(configDir, 'pikku.config.json');
+    if (!existsSync(configPath)) {
+        return false;
+    }
+    const raw = await readFile(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.emailTemplatesDir === 'string' && parsed.emailTemplatesDir) {
+        return false;
+    }
+    parsed.emailTemplatesDir = emailDir;
+    await writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+    return true;
+}
+export const pikkuEmailsInit = pikkuSessionlessFunc({
+    func: async ({ logger, config }, input) => {
+        const force = input?.force;
+        const configuredEmailDir = config.emailTemplatesDir ?? join(config.rootDir, DEFAULT_EMAIL_DIR);
+        const emailDir = config.emailTemplatesDir && config.emailTemplatesDir.length > 0
+            ? config.emailTemplatesDir
+            : join(config.rootDir, DEFAULT_EMAIL_DIR);
+        const files = [
+            [join(emailDir, 'theme.json'), `${JSON.stringify(DEFAULT_THEME, null, 2)}\n`],
+            [join(emailDir, 'locales', 'en.json'), `${JSON.stringify(DEFAULT_EN_LOCALE, null, 2)}\n`],
+            [join(emailDir, 'locales', 'de.json'), `${JSON.stringify(DEFAULT_DE_LOCALE, null, 2)}\n`],
+            [join(emailDir, 'partials', 'layout.html'), layoutTemplate()],
+            [join(emailDir, 'partials', 'footer.html'), footerPartial()],
+            [join(emailDir, 'templates', 'hello-world.html'), helloWorldHtml()],
+            [join(emailDir, 'templates', 'hello-world.subject.txt'), helloWorldSubject()],
+            [join(emailDir, 'templates', 'hello-world.text.txt'), helloWorldText()],
+        ];
+        const existing = !force
+            ? files.map(([path]) => path).filter((path) => existsSync(path))
+            : [];
+        if (existing.length > 0) {
+            logger.error(`Email scaffold already exists at ${existing[0]}. Use --force to overwrite.`);
+            process.exit(1);
+        }
+        await Promise.all(files.map(([path, content]) => ensureFile(path, content)));
+        const configUpdated = !config.emailTemplatesDir &&
+            (await updateJsonConfig(config.configDir, DEFAULT_EMAIL_DIR));
+        if (!config.emailTemplatesDir && !configUpdated) {
+            logger.warn('Unable to auto-update pikku.config.json. Add "emailTemplatesDir": "emails" manually.');
+        }
+        await generateEmailsArtifacts(logger, {
+            emailTemplatesDir: emailDir,
+            outDir: config.outDir,
+        });
+        logger.info(`Email templates initialized at ${configuredEmailDir}`);
+    },
+});

package/dist/src/functions/commands/load-user-project.js CHANGED Viewed

@@ -1,7 +1,11 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
+import { pathToFileURL } from 'url';
 import { register } from 'tsx/esm/api';
 let tsxRegistered = false;
+function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}
 /**
  * Globally register tsx so subsequent `import()` calls go through Node's
  * normal resolver — yielding ONE module graph (and one shared pikkuState),
@@ -13,22 +17,27 @@ let tsxRegistered = false;
  * module state (e.g. `pikkuState` registrations from wireHTTPRoutes).
  */
 function ensureTsxRegistered() {
+    if (isBunRuntime())
+        return;
     if (tsxRegistered)
         return;
     register();
     tsxRegistered = true;
 }
+async function importUserPath(filePath) {
+    return import(pathToFileURL(filePath).href);
+}
 /**
  * Load the generated `pikku-bootstrap.gen.{ts,js}` from the user's project,
  * which in turn pulls in all wiring/meta files so they register into
  * `pikkuState`.
  */
 export async function loadUserBootstrap(pikkuDir) {
-    ensureTsxRegistered();
     const bootstrapTs = join(pikkuDir, 'pikku-bootstrap.gen.ts');
     const bootstrapJs = join(pikkuDir, 'pikku-bootstrap.gen.js');
     const bootstrapPath = existsSync(bootstrapTs) ? bootstrapTs : bootstrapJs;
-    await import(bootstrapPath);
+    ensureTsxRegistered();
+    await importUserPath(bootstrapPath);
 }
 /**
  * Import a user-source TypeScript file (e.g. their config or services
@@ -36,5 +45,5 @@ export async function loadUserBootstrap(pikkuDir) {
  */
 export async function loadUserModule(filePath) {
     ensureTsxRegistered();
-    return import(filePath);
+    return importUserPath(filePath);
 }

package/dist/src/functions/commands/watch.js CHANGED Viewed

@@ -4,21 +4,24 @@ import { pikkuDevReloader } from '@pikku/core/dev';
 export const watch = pikkuSessionlessFunc({
     remote: true,
     func: async ({ logger, config }, { hmr }, { rpc }) => {
+        const watchDirectories = [
+            ...new Set([config.emailTemplatesDir, ...config.srcDirectories].filter(Boolean)),
+        ];
         if (hmr) {
             await pikkuDevReloader({
-                srcDirectories: config.srcDirectories,
+                srcDirectories: watchDirectories,
                 logger,
             });
         }
-        const configWatcher = chokidar.watch(config.srcDirectories, {
+        const configWatcher = chokidar.watch(watchDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
         });
         let watcher = new chokidar.FSWatcher({});
         const generatorWatcher = () => {
             watcher.close();
-            logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
-            watcher = chokidar.watch(config.srcDirectories, {
+            logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
+            watcher = chokidar.watch(watchDirectories, {
                 ignoreInitial: true,
                 ignored: /.*\.gen\.ts/,
             });

package/dist/src/functions/commands/workspace-validate.d.ts ADDED Viewed

@@ -0,0 +1,33 @@
+import { renderWorkspaceValidate } from '../validate/workspace-validate.js';
+export declare const workspaceValidate: import("#pikku").PikkuFunctionConfig<Record<string, never>, {
+    ok: boolean;
+    root: string;
+    findings: {
+        id: string;
+        severity: "info" | "warn" | "error";
+        message: string;
+        path: string;
+        fixHint: string;
+    }[];
+}, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<Record<string, never>, {
+    ok: boolean;
+    root: string;
+    findings: {
+        id: string;
+        severity: "info" | "warn" | "error";
+        message: string;
+        path: string;
+        fixHint: string;
+    }[];
+}, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<Record<string, never>, {
+    ok: boolean;
+    root: string;
+    findings: {
+        id: string;
+        severity: "info" | "warn" | "error";
+        message: string;
+        path: string;
+        fixHint: string;
+    }[];
+}, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export { renderWorkspaceValidate };

package/dist/src/functions/commands/workspace-validate.js ADDED Viewed

@@ -0,0 +1,9 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { WorkspaceValidateInput, WorkspaceValidateOutput, renderWorkspaceValidate, runWorkspaceValidate, } from '../validate/workspace-validate.js';
+export const workspaceValidate = pikkuSessionlessFunc({
+    description: 'Check the current Pikku workspace structure for compatibility. Prints all missing or misconfigured items with fix hints.',
+    input: WorkspaceValidateInput,
+    output: WorkspaceValidateOutput,
+    func: async () => runWorkspaceValidate(),
+});
+export { renderWorkspaceValidate };

package/dist/src/functions/db/coercion-plugin.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { KyselyPlugin } from 'kysely';
+export type ColumnKind = 'date' | 'bool' | 'json';
+export type CoercionMap = Record<string, Record<string, ColumnKind>>;
+export interface CreateCoercionPluginOptions {
+    map: CoercionMap;
+}
+export declare function createCoercionPlugin(options: CreateCoercionPluginOptions): KyselyPlugin;

package/dist/src/functions/db/coercion-plugin.js ADDED Viewed

@@ -0,0 +1,99 @@
+function fromDb(value, kind) {
+    if (value == null)
+        return value;
+    switch (kind) {
+        case 'date':
+            if (typeof value === 'string') {
+                const d = new Date(value);
+                return Number.isNaN(d.getTime()) ? value : d;
+            }
+            return value;
+        case 'bool':
+            if (typeof value === 'number')
+                return value !== 0;
+            if (typeof value === 'bigint')
+                return value !== 0n;
+            return value;
+        case 'json':
+            if (typeof value !== 'string')
+                return value;
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+    }
+}
+function snakeToCamel(name) {
+    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function buildGlobalMap(map) {
+    const out = {};
+    for (const [table, tbl] of Object.entries(map)) {
+        for (const [col, kind] of Object.entries(tbl)) {
+            out[`${table}.${col}`] = kind;
+            out[`${table}.${snakeToCamel(col)}`] = kind;
+            out[col] = kind;
+            out[snakeToCamel(col)] = kind;
+        }
+    }
+    return out;
+}
+function collectQueryTables(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    const op = node;
+    if (op.kind === 'TableNode') {
+        const tableName = op.table?.identifier?.name;
+        if (typeof tableName === 'string' && tableName.length > 0)
+            out.add(tableName);
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                collectQueryTables(item, out);
+        }
+        else {
+            collectQueryTables(value, out);
+        }
+    }
+}
+function lookupKind(globalMap, tables, col) {
+    let matchedKind;
+    for (const table of tables) {
+        const kind = globalMap[`${table}.${col}`];
+        if (!kind)
+            continue;
+        if (matchedKind && matchedKind !== kind)
+            return globalMap[col];
+        matchedKind = kind;
+    }
+    return matchedKind ?? globalMap[col];
+}
+export function createCoercionPlugin(options) {
+    const globalMap = buildGlobalMap(options.map);
+    const queryTables = new WeakMap();
+    return {
+        transformQuery(args) {
+            const tables = new Set();
+            collectQueryTables(args.node, tables);
+            queryTables.set(args.queryId, [...tables]);
+            return args.node;
+        },
+        async transformResult(args) {
+            const tables = queryTables.get(args.queryId) ?? [];
+            const out = [];
+            for (const row of args.result.rows) {
+                const next = { ...row };
+                for (const [col, val] of Object.entries(row)) {
+                    const kind = lookupKind(globalMap, tables, col);
+                    if (kind)
+                        next[col] = fromDb(val, kind);
+                }
+                out.push(next);
+            }
+            return { ...args.result, rows: out };
+        },
+    };
+}

package/dist/src/functions/db/local-db.d.ts CHANGED Viewed

@@ -32,8 +32,8 @@ export interface MigrateAndCodegenOutcome {
  * Run the migrate routine (open → tracking-table → drift-check → apply →
  * codegen → close). Used by both `pikku db migrate` and `pikku dev` boot.
  */
-export declare function migrateAndCodegen(resolved: ResolvedLocalDb): MigrateAndCodegenOutcome;
-export declare function seed(resolved: ResolvedLocalDb): SeedResult;
+export declare function migrateAndCodegen(resolved: ResolvedLocalDb): Promise<MigrateAndCodegenOutcome>;
+export declare function seed(resolved: ResolvedLocalDb): Promise<SeedResult>;
 /**
  * Delete the dev DB file. Refuses if NODE_ENV is 'production' or the
  * resolved file lives outside the project root (defensive against

package/dist/src/functions/db/local-db.js CHANGED Viewed

@@ -1,11 +1,12 @@
-import { DatabaseSync } from 'node:sqlite';
 import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import { resolve, isAbsolute, relative, dirname, join } from 'node:path';
-import { createNodeSqliteKysely, createCoercionPlugin, } from '@pikku/kysely-node-sqlite';
 import { migrate } from './sql-migrator.js';
 import { generateSchemaTypes } from './sqlite-codegen.js';
 import { generateZodTypes } from './zod-codegen.js';
 import { seed as runSeed } from './seed.js';
+import { createCoercionPlugin } from './coercion-plugin.js';
+import { createSqliteKysely } from './sqlite-kysely.js';
+import { loadSqliteRuntime } from './sqlite-runtime.js';
 /**
  * Resolve a DevDbConfig into absolute paths.
  * - dbFile lives under runtimeDir (default: <rootDir>/.pikku-runtime)
@@ -37,9 +38,10 @@ function resolveAgainst(root, p) {
  * Run the migrate routine (open → tracking-table → drift-check → apply →
  * codegen → close). Used by both `pikku db migrate` and `pikku dev` boot.
  */
-export function migrateAndCodegen(resolved) {
+export async function migrateAndCodegen(resolved) {
     mkdirSync(dirname(resolved.dbFile), { recursive: true });
-    const db = new DatabaseSync(resolved.dbFile);
+    const runtime = await loadSqliteRuntime();
+    const db = runtime.open(resolved.dbFile);
     try {
         const migrateResult = migrate(db, resolved.migrationsDir);
         const codegenResult = generateSchemaTypes(db, {
@@ -58,8 +60,9 @@ export function migrateAndCodegen(resolved) {
         db.close();
     }
 }
-export function seed(resolved) {
-    const db = new DatabaseSync(resolved.dbFile);
+export async function seed(resolved) {
+    const runtime = await loadSqliteRuntime();
+    const db = runtime.open(resolved.dbFile);
     try {
         return runSeed(db, resolved.seedFile);
     }
@@ -90,6 +93,8 @@ export function reset(resolved, rootDir) {
  * Wires the coercion plugin when db/coercion.gen.ts exists.
  */
 export async function createKysely(resolved) {
+    mkdirSync(dirname(resolved.dbFile), { recursive: true });
+    const runtime = await loadSqliteRuntime();
     let coercionMap;
     try {
         const mod = await import(resolved.coercionFile);
@@ -98,8 +103,8 @@ export async function createKysely(resolved) {
     catch {
         // coercion.gen.ts not yet generated — run `pikku db migrate` first
     }
-    return createNodeSqliteKysely({
-        filename: resolved.dbFile,
+    return createSqliteKysely({
+        db: runtime.open(resolved.dbFile),
         camelCase: resolved.camelCase,
         plugins: coercionMap ? [createCoercionPlugin({ map: coercionMap })] : [],
     });

package/dist/src/functions/db/seed.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { DatabaseSync } from 'node:sqlite';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
 export interface SeedResult {
     applied: boolean;
     bytes: number;
@@ -8,4 +8,4 @@ export interface SeedResult {
  * (e.g. `INSERT OR IGNORE`, upserts). Returns `applied: false` if the file
  * doesn't exist; throws on SQL errors.
  */
-export declare function seed(db: DatabaseSync, seedFile: string): SeedResult;
+export declare function seed(db: SyncSqliteDatabase, seedFile: string): SeedResult;

package/dist/src/functions/db/sql-migrator.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { DatabaseSync } from 'node:sqlite';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
 export declare class MigrationDriftError extends Error {
     readonly file: string;
     readonly recordedHash: string;
@@ -18,9 +18,9 @@ export interface MigrateResult {
  * The same bytes that get hashed are the bytes passed to db.exec — no
  * splitting, trimming, or normalization. See docs/dev-builtin-sqlite.md.
  */
-export declare function migrate(db: DatabaseSync, migrationsDir: string): MigrateResult;
+export declare function migrate(db: SyncSqliteDatabase, migrationsDir: string): MigrateResult;
 /**
  * Wipe the tracking table. Used by `pikku db reset` after the DB file is
  * removed (calling this on its own does NOT drop user tables).
  */
-export declare function dropTrackingTable(db: DatabaseSync): void;
+export declare function dropTrackingTable(db: SyncSqliteDatabase): void;

package/dist/src/functions/db/sqlite-codegen.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
-import type { DatabaseSync } from 'node:sqlite';
-import type { ColumnKind } from '@pikku/kysely-node-sqlite';
+import type { ColumnKind } from './coercion-plugin.js';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
 /** Internal annotation: column kind plus an optional TS type string (for @json). */
 interface ColAnnotation {
     kind: ColumnKind;
@@ -41,5 +41,5 @@ export interface CodegenResult {
  *
  * Returns `written: false` if the on-disk file already matches.
  */
-export declare function generateSchemaTypes(db: DatabaseSync, options: CodegenOptions): CodegenResult;
+export declare function generateSchemaTypes(db: SyncSqliteDatabase, options: CodegenOptions): CodegenResult;
 export {};

package/dist/src/functions/db/sqlite-kysely.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { Kysely, type KyselyPlugin } from 'kysely';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
+export interface CreateSqliteKyselyOptions {
+    db: SyncSqliteDatabase;
+    camelCase?: boolean;
+    plugins?: KyselyPlugin[];
+}
+export declare function createSqliteKysely<DB>(options: CreateSqliteKyselyOptions): Kysely<DB>;

package/dist/src/functions/db/sqlite-kysely.js ADDED Viewed

@@ -0,0 +1,62 @@
+import { Kysely, SqliteDialect, CamelCasePlugin, } from 'kysely';
+function coerce(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === 'boolean')
+        return v ? 1 : 0;
+    if (v instanceof Date)
+        return v.toISOString();
+    if (v instanceof Uint8Array)
+        return v;
+    if (typeof v === 'object')
+        return JSON.stringify(v);
+    return v;
+}
+class RuntimeSqliteStatement {
+    stmt;
+    reader;
+    constructor(stmt) {
+        this.stmt = stmt;
+        this.reader = Boolean(stmt.reader);
+    }
+    all(parameters) {
+        return this.stmt.all(...parameters.map(coerce));
+    }
+    *iterate(parameters) {
+        for (const row of this.stmt.iterate(...parameters.map(coerce))) {
+            yield row;
+        }
+    }
+    run(parameters) {
+        const result = this.stmt.run(...parameters.map(coerce));
+        return {
+            changes: result.changes,
+            lastInsertRowid: result.lastInsertRowid,
+        };
+    }
+}
+class RuntimeSqliteDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    prepare(sql) {
+        return new RuntimeSqliteStatement(this.db.prepare(sql));
+    }
+    close() {
+        this.db.close();
+    }
+}
+export function createSqliteKysely(options) {
+    const plugins = [];
+    if (options.camelCase ?? true)
+        plugins.push(new CamelCasePlugin());
+    if (options.plugins)
+        plugins.push(...options.plugins);
+    return new Kysely({
+        dialect: new SqliteDialect({
+            database: new RuntimeSqliteDatabase(options.db),
+        }),
+        plugins,
+    });
+}

package/dist/src/functions/db/sqlite-runtime-bun.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { SqliteRuntime } from './sqlite-runtime.js';
2	+ export declare const bunSqliteRuntime: SqliteRuntime;

package/dist/src/functions/db/sqlite-runtime-bun.js ADDED Viewed

@@ -0,0 +1,52 @@
+import { Database } from 'bun:sqlite';
+class BunSqliteStatement {
+    stmt;
+    reader;
+    constructor(stmt, reader) {
+        this.stmt = stmt;
+        this.reader = reader;
+    }
+    all(...parameters) {
+        return this.stmt.all(...parameters);
+    }
+    get(...parameters) {
+        return this.stmt.get(...parameters) ?? null;
+    }
+    iterate(...parameters) {
+        return this.stmt.iterate(...parameters);
+    }
+    run(...parameters) {
+        const result = this.stmt.run(...parameters);
+        return {
+            changes: result.changes,
+            lastInsertRowid: result.lastInsertRowid,
+        };
+    }
+}
+class BunSqliteDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    prepare(sql) {
+        return new BunSqliteStatement(this.db.prepare(sql), isReaderSql(sql));
+    }
+    close() {
+        this.db.close();
+    }
+}
+function isReaderSql(sql) {
+    const normalized = sql.trimStart().toUpperCase();
+    return (normalized.startsWith('SELECT') ||
+        normalized.startsWith('WITH') ||
+        normalized.startsWith('PRAGMA') ||
+        normalized.startsWith('EXPLAIN'));
+}
+export const bunSqliteRuntime = {
+    open(filename) {
+        return new BunSqliteDatabase(new Database(filename));
+    },
+};

package/dist/src/functions/db/sqlite-runtime-node.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { SqliteRuntime } from './sqlite-runtime.js';
2	+ export declare function createNodeSqliteRuntime(): Promise<SqliteRuntime>;