@hodela/site 0.0.0-stage → 0.2.0

package/dist/server/db.js

@@ -0,0 +1,133 @@
+// Chỉ chạy trên server (đuôi .server.ts). Import trong handler của createServerFn hoặc server route.
+//
+// Kết nối database cho website. Dùng Drizzle ORM; file này chỉ chọn driver theo CẤU HÌNH:
+//   - Mặc định: D1 của Hodela (binding PROJECT_DB, dialect sqlite).
+//   - Chủ web đổi sang database của họ trong Cài đặt → Cơ sở dữ liệu: Hodela đặt DATABASE_URL
+//     (postgresql://…, mysql://…, libsql://… ?authToken=…) và HODELA_DB_DIALECT.
+// Mã nguồn của website KHÔNG đổi khi đổi URL hoặc đổi nhà cung cấp trong cùng dialect.
+// Đổi dialect (sqlite ↔ postgres ↔ mysql) cần viết lại schema, vì mỗi dialect có kiểu bảng riêng.
+import { env } from "cloudflare:workers";
+import { splitSqlStatements } from "../sql-split.js";
+import { sql } from "drizzle-orm";
+/* eslint-enable @typescript-eslint/no-explicit-any */
+function text(name) {
+    const v = env[name];
+    return typeof v === "string" && v.trim() !== "" ? v.trim() : undefined;
+}
+function dialectFromUrl(url) {
+    if (/^postgres(ql)?:/i.test(url))
+        return "postgres";
+    if (/^mysql2?:/i.test(url))
+        return "mysql";
+    return "sqlite";
+}
+/** Dialect đang được cấu hình cho website này. Viết schema bằng đúng dialect này. */
+export function databaseDialect() {
+    const configured = text("HODELA_DB_DIALECT");
+    if (configured === "postgres" || configured === "mysql" || configured === "sqlite") {
+        return configured;
+    }
+    const url = text("DATABASE_URL");
+    return url ? dialectFromUrl(url) : "sqlite";
+}
+// Migration của website được đóng gói vào bundle lúc build: `src/lib/db.server.ts` của website chạy `import.meta.glob("/db/migrations/*.sql")`
+// rồi đưa vào `createDbAccess`. Với D1, Hodela áp trước mỗi lần build. Với database ngoài, website tự áp lúc chạy (một lần mỗi instance).
+let migrationFiles = {};
+/** Gọi một lần trong `src/lib/db.server.ts` của website; trả về `getDb` và `databaseDialect` đã gắn migration của website đó. */
+export function createDbAccess(files) {
+    migrationFiles = files;
+    return { getDb, databaseDialect };
+}
+function migrations() {
+    return Object.entries(migrationFiles)
+        .map(([path, body]) => ({ name: path.split("/").pop() ?? path, sql: body }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+async function sha256(textValue) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(textValue));
+    return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function execute(db, dialect, query) {
+    if (dialect === "sqlite") {
+        const out = await db.all(query);
+        return Array.isArray(out) ? out : [];
+    }
+    const out = await db.execute(query);
+    if (dialect === "mysql")
+        return Array.isArray(out?.[0]) ? out[0] : [];
+    return Array.isArray(out) ? out : (out?.rows ?? []);
+}
+let migrated;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function runMigrations(db, dialect) {
+    const files = migrations();
+    if (files.length === 0)
+        return;
+    await execute(db, dialect, sql.raw("CREATE TABLE IF NOT EXISTS _hodela_migrations (name VARCHAR(255) PRIMARY KEY, checksum VARCHAR(64) NOT NULL)"));
+    const rows = (await execute(db, dialect, sql.raw("SELECT name, checksum FROM _hodela_migrations")));
+    const applied = new Map(rows.map((r) => [r.name, r.checksum]));
+    for (const file of files) {
+        const checksum = await sha256(file.sql);
+        const prior = applied.get(file.name);
+        if (prior !== undefined) {
+            if (prior !== checksum) {
+                throw new Error(`Migration ${file.name} đã áp rồi nhưng nội dung bị sửa. Tạo file migration mới thay vì sửa file cũ.`);
+            }
+            continue;
+        }
+        for (const statement of splitSqlStatements(file.sql, dialect)) {
+            await execute(db, dialect, sql.raw(statement.sql));
+        }
+        await execute(db, dialect, sql.raw(`INSERT INTO _hodela_migrations (name, checksum) VALUES ('${file.name.replace(/'/g, "''")}', '${checksum}')`));
+    }
+}
+/**
+ * Trả về đối tượng Drizzle đã kết nối. Gọi một lần trong mỗi server function (đừng giữ ở biến module:
+ * kết nối TCP không dùng lại giữa các request trên Cloudflare Workers).
+ *
+ *   const db = await getDb();                 // sqlite: D1 hoặc libsql
+ *   const db = await getDb<"postgres">();     // khi website dùng Postgres
+ */
+export async function getDb() {
+    const url = text("DATABASE_URL");
+    const dialect = databaseDialect();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let db;
+    if (!url) {
+        const d1 = env["PROJECT_DB"];
+        if (!d1) {
+            throw new Error("Website chưa có database. Thêm file db/migrations/0001_*.sql để Hodela tạo database, hoặc cấu hình database của bạn trong Cài đặt → Cơ sở dữ liệu.");
+        }
+        const { drizzle } = await import("drizzle-orm/d1");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        db = drizzle(d1);
+    }
+    else if (dialect === "postgres") {
+        const { default: postgres } = await import("postgres");
+        const { drizzle } = await import("drizzle-orm/postgres-js");
+        db = drizzle(postgres(url, { max: 1, prepare: false }));
+    }
+    else if (dialect === "mysql") {
+        const mysql = await import("mysql2/promise");
+        const { drizzle } = await import("drizzle-orm/mysql2");
+        db = drizzle(mysql.createPool(url));
+    }
+    else {
+        const { createClient } = await import("@libsql/client/web");
+        const { drizzle } = await import("drizzle-orm/libsql/web");
+        const parsed = new URL(url);
+        const authToken = parsed.searchParams.get("authToken") ?? undefined;
+        parsed.searchParams.delete("authToken");
+        db = drizzle(createClient({ url: parsed.toString().replace(/\?$/, ""), ...(authToken ? { authToken } : {}) }));
+    }
+    // D1 mặc định: Hodela đã áp migration lúc build. Database ngoài: website tự áp.
+    if (url) {
+        migrated ??= runMigrations(db, dialect).catch((error) => {
+            migrated = undefined;
+            throw error;
+        });
+        await migrated;
+    }
+    return db;
+}

package/dist/server/entry.d.ts

@@ -0,0 +1,4 @@
+import "./error-capture.js";
+export declare function createHodelaServerEntry(loadServerEntry: () => Promise<unknown>): {
+    fetch(request: Request, env: unknown, ctx: unknown): Promise<Response>;
+};

package/dist/server/entry.js

@@ -0,0 +1,97 @@
+// Điểm vào worker của website: PIN/IP/chặn bot trước khi chạy ứng dụng, chèn analytics và badge sau khi chạy, trang lỗi thống nhất.
+// `src/server.ts` của website chỉ gọi `createHodelaServerEntry(() => import("@tanstack/react-start/server-entry"))`.
+import "./error-capture.js";
+import { consumeLastCapturedError } from "./error-capture.js";
+import { badgeHtml, enforceAccess, parseAccessConfig } from "../access.js";
+import { analyticsHeadSnippet, parseAnalyticsConfig } from "../analytics.js";
+import { renderErrorPage } from "../error-page.js";
+// h3 swallows in-handler throws into a normal 500 Response with body
+// {"unhandled":true,"message":"HTTPError"} — try/catch alone never fires for those.
+async function normalizeCatastrophicSsrResponse(response) {
+    if (response.status < 500)
+        return response;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("application/json"))
+        return response;
+    const body = await response.clone().text();
+    if (!isH3SwallowedErrorBody(body))
+        return response;
+    console.error(consumeLastCapturedError() ?? new Error(`h3 swallowed SSR error: ${body}`));
+    return new Response(renderErrorPage(), {
+        status: 500,
+        headers: { "content-type": "text/html; charset=utf-8" },
+    });
+}
+function isH3SwallowedErrorBody(body) {
+    try {
+        const payload = JSON.parse(body);
+        return payload.unhandled === true && payload.message === "HTTPError";
+    }
+    catch {
+        return false;
+    }
+}
+// Mã đo lường và badge chủ web bật/được áp trong cài đặt: chỉ chèn khi đã xuất bản, không chèn ở bản xem trước.
+function withInjections(response, env) {
+    const bindings = (env ?? {});
+    if (bindings["HODELA_ENV"] !== "production")
+        return response;
+    const type = response.headers.get("content-type") ?? "";
+    if (!type.includes("text/html"))
+        return response;
+    const snippet = analyticsHeadSnippet(parseAnalyticsConfig(bindings["HODELA_ANALYTICS"]));
+    const badge = badgeHtml(parseAccessConfig(bindings["HODELA_ACCESS"]));
+    const Rewriter = globalThis.HTMLRewriter;
+    if ((!snippet && !badge) || !Rewriter)
+        return response;
+    let rewriter = new Rewriter();
+    if (snippet) {
+        rewriter = rewriter.on("head", {
+            element(el) {
+                el.append(snippet, { html: true });
+            },
+        });
+    }
+    if (badge) {
+        rewriter = rewriter.on("body", {
+            element(el) {
+                el.append(badge, { html: true });
+            },
+        });
+    }
+    return rewriter.transform(response);
+}
+// PIN, danh sách IP và chặn bot của site đã xuất bản; chặn trước khi chạy ứng dụng.
+async function blockedByAccess(request, env) {
+    const bindings = (env ?? {});
+    if (bindings["HODELA_ENV"] !== "production")
+        return null;
+    const secret = typeof bindings["HODELA_SESSION_SECRET"] === "string" ? bindings["HODELA_SESSION_SECRET"] : "";
+    return enforceAccess(request, parseAccessConfig(bindings["HODELA_ACCESS"]), secret);
+}
+export function createHodelaServerEntry(loadServerEntry) {
+    let serverEntryPromise;
+    const getServerEntry = () => {
+        serverEntryPromise ??= loadServerEntry().then((m) => (m.default ?? m));
+        return serverEntryPromise;
+    };
+    return {
+        async fetch(request, env, ctx) {
+            try {
+                const blocked = await blockedByAccess(request, env);
+                if (blocked)
+                    return blocked;
+                const handler = await getServerEntry();
+                const response = await handler.fetch(request, env, ctx);
+                return withInjections(await normalizeCatastrophicSsrResponse(response), env);
+            }
+            catch (error) {
+                console.error(error);
+                return new Response(renderErrorPage(), {
+                    status: 500,
+                    headers: { "content-type": "text/html; charset=utf-8" },
+                });
+            }
+        },
+    };
+}

package/dist/server/env.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Biến môi trường do chủ web cấu hình trong Cài đặt → Environments (ví dụ RESEND_API_KEY).
+ * Trả về undefined nếu chưa cấu hình: code phải chạy được khi thiếu, đừng hardcode giá trị.
+ */
+export declare function serverEnv(name: string): string | undefined;
+/** "preview" khi xem thử trong editor, "production" khi đã xuất bản. */
+export declare function hodelaEnv(): "preview" | "production";

package/dist/server/env.js

@@ -0,0 +1,14 @@
+// Chỉ chạy trên server (đuôi .server.ts). Import trong handler của createServerFn hoặc server route.
+import { env } from "cloudflare:workers";
+/**
+ * Biến môi trường do chủ web cấu hình trong Cài đặt → Environments (ví dụ RESEND_API_KEY).
+ * Trả về undefined nếu chưa cấu hình: code phải chạy được khi thiếu, đừng hardcode giá trị.
+ */
+export function serverEnv(name) {
+    const value = env[name];
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+/** "preview" khi xem thử trong editor, "production" khi đã xuất bản. */
+export function hodelaEnv() {
+    return env["HODELA_ENV"] === "production" ? "production" : "preview";
+}

package/dist/server/error-capture.d.ts

@@ -0,0 +1,2 @@
+export declare function describeError(error: unknown): string;
+export declare function consumeLastCapturedError(): unknown;

package/dist/server/error-capture.js

@@ -0,0 +1,72 @@
+// Captures the original Error out-of-band so server.ts can recover the stack
+// when h3 has already swallovwed the throw into a generic 500 Response.
+let lastCapturedError;
+const TTL_MS = 5_000;
+function record(error) {
+    lastCapturedError = { error, at: Date.now() };
+}
+// h3's HTTPError serializes to {"status":500,"unhandled":true,"message":"HTTPError"} —
+// no stack, no cause — so a plain console.error(error) reaches the log pipeline with
+// the failure detail stripped. Expand Error-like args into a string that keeps the
+// message, stack, and the full cause chain.
+const CAUSE_DEPTH_LIMIT = 5;
+const DESCRIPTION_LENGTH_LIMIT = 8_000;
+export function describeError(error) {
+    const parts = [];
+    let current = error;
+    for (let depth = 0; depth < CAUSE_DEPTH_LIMIT && current != null; depth++) {
+        if (!(current instanceof Error)) {
+            parts.push(typeof current === "string" ? current : safeStringify(current));
+            break;
+        }
+        const label = depth === 0 ? "" : "caused by: ";
+        const status = describeStatus(current);
+        parts.push(`${label}${current.stack ?? `${current.name}: ${current.message}`}${status}`);
+        current = current.cause;
+    }
+    return parts.join("\n").slice(0, DESCRIPTION_LENGTH_LIMIT);
+}
+function describeStatus(error) {
+    const { status, statusCode } = error;
+    const value = status ?? statusCode;
+    return typeof value === "number" ? ` (status ${value})` : "";
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function isErrorLike(value) {
+    return value instanceof Error;
+}
+// Wrap console.error so errors logged by any layer — including h3's internal
+// unhandled-error logging, which this file cannot hook directly — are both
+// recorded for consumeLastCapturedError and expanded before serialization.
+const originalConsoleError = console.error.bind(console);
+console.error = (...args) => {
+    const expanded = args.map((arg) => {
+        if (!isErrorLike(arg))
+            return arg;
+        record(arg);
+        return describeError(arg);
+    });
+    originalConsoleError(...expanded);
+};
+if (typeof globalThis.addEventListener === "function") {
+    globalThis.addEventListener("error", (event) => record(event.error ?? event));
+    globalThis.addEventListener("unhandledrejection", (event) => record(event.reason));
+}
+export function consumeLastCapturedError() {
+    if (!lastCapturedError)
+        return undefined;
+    if (Date.now() - lastCapturedError.at > TTL_MS) {
+        lastCapturedError = undefined;
+        return undefined;
+    }
+    const { error } = lastCapturedError;
+    lastCapturedError = undefined;
+    return error;
+}

package/dist/server/files.d.ts

@@ -0,0 +1,17 @@
+export { describeFileError, HodelaFileError } from "@hodela/file-js";
+export declare function files(): {
+    put(body: import("@hodela/file-js").FileBody, opts?: import("@hodela/file-js").PutFileOptions): Promise<import("@hodela/file-js").PutFileResult>;
+    get: (id: string) => Promise<import("@hodela/file-js").HodelaFile>;
+    list: (opts?: {
+        limit?: number;
+        before?: string;
+    }) => Promise<{
+        data: import("@hodela/file-js").HodelaFile[];
+        nextBefore: string | null;
+    }>;
+    usage: () => Promise<import("@hodela/file-js").FileUsage>;
+    signedUrl: (id: string, opts?: {
+        ttlSec?: number;
+    }) => Promise<import("@hodela/file-js").SignedUrl>;
+    delete(id: string): Promise<void>;
+};

package/dist/server/files.js

@@ -0,0 +1,21 @@
+// Chỉ chạy trên server. Hodela quản lý file này: không sửa. Dùng trong server function:
+//
+//   import { files } from "@hodela/site/server/files";
+//   const saved = await files().put(file);          // file: File lấy từ FormData
+//   // saved.url dùng thẳng trong <img src> hoặc <a href>, lưu vào database cạnh bản ghi.
+//
+// Cùng một đoạn mã chạy ở mọi nơi:
+//   • Hodela (xem thử và đã xuất bản): kho file của nền tảng (R2) qua HODELA_API_URL / HODELA_API_KEY do Hodela cấp.
+//   • Máy dev (`pnpm dev`, không có hai biến trên): plugin Vite ghi ảnh vào public/hodela-media (@hodela/dev).
+import { createHodelaFileClient } from "@hodela/file-js";
+import { getRequestUrl } from "@tanstack/react-start/server";
+import { serverEnv } from "./env.js";
+export { describeFileError, HodelaFileError } from "@hodela/file-js";
+export function files() {
+    const apiUrl = serverEnv("HODELA_API_URL");
+    const apiKey = serverEnv("HODELA_API_KEY");
+    if (apiUrl && apiKey)
+        return createHodelaFileClient({ apiUrl, apiKey });
+    // Không có khóa của Hodela: đang chạy ở máy dev, dùng kho giả lập của Vite dev server (cùng origin với trang đang mở).
+    return createHodelaFileClient({ apiUrl: `${getRequestUrl().origin}/__hodela/dev`, apiKey: "dev" });
+}

package/dist/server/mailer.d.ts

@@ -0,0 +1,10 @@
+import { createMailer, type MailProvider } from "../mailer.js";
+export { escapeMailHtml, type MailInput, type MailProvider, type MailResult } from "../mailer.js";
+export declare const sendMail: ReturnType<typeof createMailer>["sendMail"];
+export declare const recentMail: ReturnType<typeof createMailer>["recentMail"];
+export declare const notifyOwner: ReturnType<typeof createMailer>["notifyOwner"];
+/** Cho giao diện quản lý biết thông báo email đang bật hay tắt (không lộ khóa). */
+export declare function mailStatus(): {
+    provider: MailProvider;
+    notifyEmail: string | null;
+};

package/dist/server/mailer.js

@@ -0,0 +1,16 @@
+// Chỉ chạy trên server. Hodela quản lý file này: không sửa. Xem giải thích trong "../mailer.js".
+//
+//   import { notifyOwner, sendMail } from "@hodela/site/server/mailer";
+//   // Sau khi ĐÃ lưu dữ liệu vào database (không await lỗi, không để lỗi mail làm hỏng đơn):
+//   await notifyOwner({ subject: "Đơn hàng mới #123", text: "...", replyTo: khach.email });
+import { createMailer, mailProvider } from "../mailer.js";
+import { hodelaEnv, serverEnv } from "./env.js";
+export { escapeMailHtml } from "../mailer.js";
+const mailer = () => createMailer({ env: serverEnv, mode: hodelaEnv() });
+export const sendMail = (input) => mailer().sendMail(input);
+export const recentMail = (limit) => mailer().recentMail(limit);
+export const notifyOwner = (input) => mailer().notifyOwner(input);
+/** Cho giao diện quản lý biết thông báo email đang bật hay tắt (không lộ khóa). */
+export function mailStatus() {
+    return { provider: mailProvider(serverEnv), notifyEmail: serverEnv("NOTIFY_EMAIL") ?? null };
+}

package/dist/server/session-cookie.d.ts

@@ -0,0 +1,2 @@
+import { type SessionCookieOptions } from "../session-cookie.js";
+export declare function sessionCookie(maxAgeSeconds: number): SessionCookieOptions;

package/dist/server/session-cookie.js

@@ -0,0 +1,7 @@
+// Chỉ chạy trên server. Gắn thuộc tính cookie phiên (xem session-cookie.ts) theo request hiện tại. Hodela quản lý file này: không sửa.
+import { getRequestUrl } from "@tanstack/react-start/server";
+import { hodelaEnv } from "./env.js";
+import { sessionCookieOptions } from "../session-cookie.js";
+export function sessionCookie(maxAgeSeconds) {
+    return sessionCookieOptions(hodelaEnv(), getRequestUrl(), maxAgeSeconds);
+}

package/dist/session-cookie.d.ts

@@ -0,0 +1,15 @@
+/** `localhost`, `*.localhost`, `127.0.0.1`, `[::1]`: trình duyệt chấp nhận cookie `Secure` kể cả qua http. */
+export declare function isLocalHost(hostname: string): boolean;
+export type SessionCookieOptions = {
+    httpOnly: true;
+    path: "/";
+    maxAge: number;
+    secure: boolean;
+    sameSite: "lax" | "none";
+    partitioned?: true;
+};
+/** Thuần (dễ kiểm thử): chọn thuộc tính theo môi trường, giao thức và host của request. */
+export declare function sessionCookieOptions(env: "preview" | "production", url: {
+    protocol: string;
+    hostname: string;
+}, maxAgeSeconds: number): SessionCookieOptions;

package/dist/session-cookie.js

@@ -0,0 +1,18 @@
+// Thuộc tính cookie phiên dùng chung cho quản lý và khách. Hodela quản lý file này: không sửa.
+//
+// Preview chạy trong iframe của editor (khác site với editor nên cookie `lax` bị coi là bên thứ ba và bị chặn: đăng nhập
+// báo đúng nhưng không giữ được phiên, trong khi mở tab riêng thì được). Vì vậy preview dùng `SameSite=None; Secure;
+// Partitioned` (CHIPS: cookie gắn với trang editor chứa iframe nên không phải cookie theo dõi xuyên site). Production không
+// bị nhúng nên giữ `lax`, đây là mặc định an toàn nhất chống CSRF.
+/** `localhost`, `*.localhost`, `127.0.0.1`, `[::1]`: trình duyệt chấp nhận cookie `Secure` kể cả qua http. */
+export function isLocalHost(hostname) {
+    return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+/** Thuần (dễ kiểm thử): chọn thuộc tính theo môi trường, giao thức và host của request. */
+export function sessionCookieOptions(env, url, maxAgeSeconds) {
+    const secureContext = url.protocol === "https:" || isLocalHost(url.hostname);
+    if (env !== "production" && secureContext) {
+        return { httpOnly: true, path: "/", maxAge: maxAgeSeconds, secure: true, sameSite: "none", partitioned: true };
+    }
+    return { httpOnly: true, path: "/", maxAge: maxAgeSeconds, secure: env === "production", sameSite: "lax" };
+}

package/dist/sql-split.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tách câu lệnh SQL cho migration. MỘT thuật toán duy nhất cho mọi nơi: kiểm tra, áp lên D1, áp lên
+ * database ngoài. File này được sao nguyên văn vào starter (`src/lib/sql-split.ts`) để website tự áp
+ * migration lúc chạy; test so khớp hai bản trên cùng một bộ mẫu. Không import gì để sao chép được.
+ */
+export type SqlDialect = "sqlite" | "postgres" | "mysql";
+export type SqlToken = {
+    kind: "word" | "ident" | "string" | "number" | "punct";
+    /** word: chữ HOA; ident: tên đã bỏ dấu nháy (giữ nguyên chữ hoa/thường); còn lại: văn bản gốc. */
+    text: string;
+    line: number;
+};
+export type SqlStatement = {
+    /** Câu lệnh đã bỏ chú thích, không có dấu `;` cuối. Đây chính là chuỗi được chạy. */
+    sql: string;
+    tokens: SqlToken[];
+    /** Dòng bắt đầu (1-based) trong file gốc, để báo lỗi. */
+    line: number;
+};
+export declare class SqlSyntaxError extends Error {
+    readonly line: number;
+    constructor(message: string, line: number);
+}
+export declare function splitSqlStatements(source: string, dialect?: SqlDialect): SqlStatement[];

package/dist/sql-split.js

@@ -0,0 +1,182 @@
+/**
+ * Tách câu lệnh SQL cho migration. MỘT thuật toán duy nhất cho mọi nơi: kiểm tra, áp lên D1, áp lên
+ * database ngoài. File này được sao nguyên văn vào starter (`src/lib/sql-split.ts`) để website tự áp
+ * migration lúc chạy; test so khớp hai bản trên cùng một bộ mẫu. Không import gì để sao chép được.
+ */
+export class SqlSyntaxError extends Error {
+    line;
+    constructor(message, line) {
+        super(message);
+        this.line = line;
+    }
+}
+const WORD_START = /[A-Za-z_\u0080-￿]/;
+const WORD_PART = /[A-Za-z0-9_$\u0080-￿]/;
+export function splitSqlStatements(source, dialect = "sqlite") {
+    const out = [];
+    let text = "";
+    let tokens = [];
+    let startLine = 0;
+    let line = 1;
+    let i = 0;
+    const n = source.length;
+    const push = (t, raw) => {
+        if (!startLine)
+            startLine = t.line;
+        tokens.push(t);
+        text += raw;
+    };
+    const flush = () => {
+        const sql = text.trim();
+        if (sql)
+            out.push({ sql, tokens, line: startLine || line });
+        text = "";
+        tokens = [];
+        startLine = 0;
+    };
+    const sep = () => {
+        if (text && !text.endsWith(" "))
+            text += " ";
+    };
+    while (i < n) {
+        const c = source[i];
+        const next = source[i + 1];
+        if (c === "\n") {
+            line += 1;
+            sep();
+            i += 1;
+            continue;
+        }
+        if (c === " " || c === "\t" || c === "\r") {
+            sep();
+            i += 1;
+            continue;
+        }
+        if (c === "-" && next === "-") {
+            while (i < n && source[i] !== "\n")
+                i += 1;
+            sep();
+            continue;
+        }
+        if (c === "/" && next === "*") {
+            const startedAt = line;
+            i += 2;
+            while (i < n && !(source[i] === "*" && source[i + 1] === "/")) {
+                if (source[i] === "\n")
+                    line += 1;
+                i += 1;
+            }
+            if (i >= n)
+                throw new SqlSyntaxError("Chú thích /* không được đóng", startedAt);
+            i += 2;
+            sep();
+            continue;
+        }
+        if (c === ";") {
+            flush();
+            i += 1;
+            continue;
+        }
+        // Chuỗi '...' (và E'...' của PostgreSQL; MySQL cho phép \ thoát ký tự).
+        if (c === "'") {
+            const startedAt = line;
+            const prev = source[i - 1];
+            const backslash = dialect === "mysql" || (dialect === "postgres" && (prev === "E" || prev === "e"));
+            let j = i + 1;
+            let closed = false;
+            while (j < n) {
+                const d = source[j];
+                if (d === "\n")
+                    line += 1;
+                if (backslash && d === "\\") {
+                    j += 2;
+                    continue;
+                }
+                if (d === "'") {
+                    if (source[j + 1] === "'") {
+                        j += 2;
+                        continue;
+                    }
+                    closed = true;
+                    break;
+                }
+                j += 1;
+            }
+            if (!closed)
+                throw new SqlSyntaxError("Chuỗi ' không được đóng", startedAt);
+            const raw = source.slice(i, j + 1);
+            push({ kind: "string", text: raw, line: startedAt }, raw);
+            i = j + 1;
+            continue;
+        }
+        // Tên có nháy: "..." (chuẩn), `...` (MySQL).
+        if (c === '"' || c === "`") {
+            const startedAt = line;
+            let j = i + 1;
+            let name = "";
+            let closed = false;
+            while (j < n) {
+                const d = source[j];
+                if (d === "\n")
+                    line += 1;
+                if (d === c) {
+                    if (source[j + 1] === c) {
+                        name += c;
+                        j += 2;
+                        continue;
+                    }
+                    closed = true;
+                    break;
+                }
+                name += d;
+                j += 1;
+            }
+            if (!closed)
+                throw new SqlSyntaxError(`Tên ${c}...${c} không được đóng`, startedAt);
+            const raw = source.slice(i, j + 1);
+            push({ kind: "ident", text: name, line: startedAt }, raw);
+            i = j + 1;
+            continue;
+        }
+        // Chuỗi dollar-quote của PostgreSQL: $$...$$ hoặc $tag$...$tag$.
+        if (c === "$" && dialect === "postgres") {
+            const m = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(source.slice(i, i + 80));
+            if (m) {
+                const startedAt = line;
+                const tag = m[0];
+                const end = source.indexOf(tag, i + tag.length);
+                if (end < 0)
+                    throw new SqlSyntaxError(`Chuỗi ${tag} không được đóng`, startedAt);
+                const raw = source.slice(i, end + tag.length);
+                for (const ch of raw)
+                    if (ch === "\n")
+                        line += 1;
+                push({ kind: "string", text: raw, line: startedAt }, raw);
+                i = end + tag.length;
+                continue;
+            }
+        }
+        if (WORD_START.test(c)) {
+            let j = i + 1;
+            while (j < n && WORD_PART.test(source[j]))
+                j += 1;
+            const raw = source.slice(i, j);
+            push({ kind: "word", text: raw.toUpperCase(), line }, raw);
+            i = j;
+            continue;
+        }
+        if (/[0-9]/.test(c)) {
+            let j = i + 1;
+            while (j < n && /[0-9A-Za-z_.]/.test(source[j]))
+                j += 1;
+            const raw = source.slice(i, j);
+            push({ kind: "number", text: raw, line }, raw);
+            i = j;
+            continue;
+        }
+        push({ kind: "punct", text: c, line }, c);
+        i += 1;
+    }
+    flush();
+    return out;
+}