@absolutejs/absolute 0.20.0-beta.120 → 0.20.0-beta.121

package/dist/src/cli/scripts/db.d.ts

@@ -1,20 +1,3 @@
-type ColumnMeta = {
-    isJson: boolean;
-    name: string;
-};
-type TableMeta = {
-    columns: ColumnMeta[];
-    name: string;
-    primaryKey: string[];
-};
-type ForeignLink = {
-    from: string;
-    to: string;
-};
-export declare const chunkRows: <Item>(items: Item[], size: number) => Item[][];
-export declare const quoteIdent: (name: string) => string;
-export declare const conflictClause: (meta: TableMeta) => string;
-export declare const dependencyOrder: (names: string[], links: ForeignLink[]) => string[];
-export declare const encodeValue: (col: ColumnMeta, value: unknown) => {} | null;
+export { chunkRows, conflictClause, dependencyOrder, quoteIdent } from './dbEngines/sqlText';
+export { encodeValue } from './dbEngines/values';
 export declare const runDb: (args: string[]) => Promise<void>;
-export {};

package/dist/src/cli/scripts/dbEngines/detect.d.ts

@@ -0,0 +1,8 @@
+import type { DbTarget, OrmDialectHint } from '../../../../types/db';
+export declare const SUPPORTED_SCHEMES = "postgres://, postgresql://, cockroachdb://, mysql://, mariadb://, singlestore://, file:, sqlite:, libsql://, http(s)://, ws(s)://, sqlserver://, mssql://";
+export declare const readOrmDialect: (cwd: string) => {
+    dialect: string;
+    source: string;
+} | undefined;
+export declare const detectTarget: (url: string, hint: OrmDialectHint | undefined) => DbTarget;
+export declare const sqlitePath: (url: string, cwd: string) => string;

package/dist/src/cli/scripts/dbEngines/mssql.d.ts

@@ -0,0 +1,4 @@
+import type { DbConnection, MssqlColumnRow, MssqlTarget } from '../../../../types/db';
+export declare const mssqlColumnType: (row: MssqlColumnRow) => string;
+export declare const parseMssqlUrl: (url: string) => MssqlTarget;
+export declare const openMssql: (url: string) => Promise<DbConnection>;

package/dist/src/cli/scripts/dbEngines/mysql.d.ts

@@ -0,0 +1,2 @@
+import type { DbConnection } from '../../../../types/db';
+export declare const openMysql: (url: string) => Promise<DbConnection>;

package/dist/src/cli/scripts/dbEngines/open.d.ts

@@ -0,0 +1,2 @@
+import type { DbTarget } from '../../../../types/db';
+export declare const openConnection: (target: DbTarget, cwd: string) => Promise<import("../../../../types/db").DbConnection>;

package/dist/src/cli/scripts/dbEngines/postgres.d.ts

@@ -0,0 +1,2 @@
+import type { DbConnection } from '../../../../types/db';
+export declare const openPostgres: (url: string) => Promise<DbConnection>;

package/dist/src/cli/scripts/dbEngines/sqlText.d.ts

@@ -0,0 +1,13 @@
+import type { DbColumnMeta, DbForeignLink, DbTableMeta } from '../../../../types/db';
+export declare const chunkRows: <Item>(items: Item[], size: number) => Item[][];
+export declare const insertableColumns: (meta: DbTableMeta) => DbColumnMeta[];
+export declare const quoteIdent: (name: string) => string;
+export declare const quoteMssqlIdent: (name: string) => string;
+export declare const quoteMysqlIdent: (name: string) => string;
+export declare const rowsPerChunk: (columnCount: number, paramLimit: number) => number;
+export declare const conflictClause: (meta: DbTableMeta) => string;
+export declare const mysqlInsert: (meta: DbTableMeta, rowCount: number, rowAlias: boolean) => string;
+export declare const postgresInsert: (meta: DbTableMeta, rowCount: number, overridingSystemValue: boolean) => string;
+export declare const sqliteInsert: (meta: DbTableMeta, rowCount: number) => string;
+export declare const dependencyOrder: (names: string[], links: DbForeignLink[]) => string[];
+export declare const mssqlUpsert: (meta: DbTableMeta, rowCount: number, qualifiedTable: string) => string;

package/dist/src/cli/scripts/dbEngines/sqlite.d.ts

@@ -0,0 +1,4 @@
+import type { DbConnection, DbEngine, SqliteExecutor } from '../../../../types/db';
+export declare const bunSqliteExecutor: (path: string) => SqliteExecutor;
+export declare const libsqlExecutor: (url: string) => Promise<SqliteExecutor>;
+export declare const openSqlite: (exec: SqliteExecutor, engine: DbEngine) => DbConnection;

package/dist/src/cli/scripts/dbEngines/values.d.ts

@@ -0,0 +1,12 @@
+import type { DbColumnMeta, DbRow } from '../../../../types/db';
+export declare const decodeBinary: (value: unknown) => Buffer<ArrayBuffer> | undefined;
+export declare const parseJsonText: (value: unknown) => unknown;
+export declare const encodeMssqlValue: (col: DbColumnMeta, value: unknown) => {} | null;
+export declare const encodeMysqlValue: (col: DbColumnMeta, value: unknown) => {} | null;
+export declare const encodeSqliteValue: (col: DbColumnMeta, value: unknown) => {} | null;
+export declare const encodeValue: (col: DbColumnMeta, value: unknown) => {} | null;
+export declare const isoToSqlDateTime: (value: string) => string;
+export declare const pgArrayLiteral: (values: unknown[]) => string;
+export declare const normalizeRow: (row: DbRow) => {
+    [k: string]: unknown;
+};

package/dist/src/cli/utils.d.ts

@@ -3,6 +3,13 @@ export declare const COMPOSE_PATH = "db/docker-compose.db.yml";
 export declare const DEFAULT_SERVER_ENTRY = "src/backend/server.ts";
 export declare const isWSLEnvironment: () => boolean;
 export declare const findFreePort: () => Promise<number>;
+/**
+ * Whether a process holding the port is a leftover of this project's own
+ * AbsoluteJS server, and so safe to replace. Anything else on the port -- an
+ * unrelated service, or another project's server -- is someone else's and is
+ * left running.
+ */
+export declare const isOwnStaleProcess: (command: string, directory: string | null, projectDirectory: string) => boolean;
 export declare const killStaleProcesses: (port: number, logMessage?: (message: string) => void) => void;
 export declare const openUrlInBrowser: (url: string, onError?: (message: string) => void) => boolean;
 export declare const printHelp: (subject?: string, mobile?: boolean) => void;

package/dist/src/utils/userAgentFunctions.d.ts

@@ -1 +1 @@
-export declare const getUserAgentType: (userAgent: string) => "console" | "phone" | "other" | "tablet" | "desktop" | "bot" | "tv" | "car" | "iot";
+export declare const getUserAgentType: (userAgent: string) => "other" | "console" | "phone" | "tablet" | "desktop" | "bot" | "tv" | "car" | "iot";

package/dist/types/db.d.ts

@@ -0,0 +1,109 @@
+export type DbFamily = 'libsql' | 'mssql' | 'mysql' | 'postgres' | 'sqlite';
+export type DbEngine = 'cockroach' | 'libsql' | 'mariadb' | 'mssql' | 'mysql' | 'postgres' | 'singlestore' | 'sqlite';
+export type DbColumnKind = 'array' | 'binary' | 'json' | 'other' | 'temporal';
+export type DbColumnMeta = {
+    generated?: boolean;
+    identity?: boolean;
+    isJson: boolean;
+    kind?: DbColumnKind;
+    name: string;
+    sqlType?: string;
+};
+export type DbTableMeta = {
+    columns: DbColumnMeta[];
+    name: string;
+    primaryKey: string[];
+};
+export type DbForeignLink = {
+    from: string;
+    to: string;
+};
+export type DbRow = Record<string, unknown>;
+export type DbBackupFile = {
+    at: string;
+    engine?: DbEngine;
+    tables: Record<string, DbRow[]>;
+    v: number;
+};
+export type DbOptions = {
+    exclude: string[];
+    only: string[];
+    out?: string;
+    truncate: boolean;
+    url: string;
+    yes: boolean;
+};
+export type DbConnection = {
+    afterRestore: (restored: DbTableMeta[]) => Promise<void>;
+    close: () => Promise<void>;
+    engine: DbEngine;
+    foreignLinks: () => Promise<DbForeignLink[]>;
+    insertRows: (meta: DbTableMeta, rows: DbRow[]) => Promise<void>;
+    listTables: () => Promise<string[]>;
+    readRows: (meta: DbTableMeta) => Promise<DbRow[]>;
+    tableMeta: (name: string) => Promise<DbTableMeta>;
+    truncate: (names: string[]) => Promise<void>;
+};
+export type DbTarget = {
+    family: DbFamily;
+    url: string;
+};
+export type OrmDialectHint = {
+    dialect: string;
+    source: string;
+};
+export type MysqlConnectOptions = {
+    allowPublicKeyRetrieval: boolean;
+    url: string;
+};
+export type MssqlTarget = {
+    database?: string;
+    encrypt: boolean;
+    instanceName?: string;
+    password?: string;
+    port?: number;
+    server: string;
+    trustServerCertificate: boolean;
+    user?: string;
+};
+export type SqliteExecutor = {
+    all: (query: string, params: unknown[]) => Promise<DbRow[]>;
+    batch: (statements: string[]) => Promise<void>;
+    close: () => Promise<void>;
+    run: (query: string, params: unknown[]) => Promise<void>;
+};
+export type PgColumnRow = {
+    column_default: string | null;
+    column_name: string;
+    data_type: string;
+    identity_generation: string | null;
+    is_generated: string | null;
+    is_identity: string | null;
+};
+export type MysqlColumnRow = {
+    data_type: string;
+    extra: string | null;
+    name: string;
+};
+export type SqliteColumnRow = {
+    hidden: unknown;
+    name: string;
+    pk: unknown;
+    type: string | null;
+};
+export type MssqlColumnRow = {
+    is_computed: boolean;
+    is_identity: boolean;
+    max_length: number;
+    name: string;
+    precision: number;
+    scale: number;
+    type: string;
+};
+export type NamedRow = {
+    name: string;
+};
+export type LinkRow = {
+    child: string;
+    parent: string;
+};

package/package.json

@@ -76,12 +76,14 @@
 		"@glimmer/component": "^2.1.1",
 		"@glimmer/tracking": "^1.1.2",
 		"@happy-dom/global-registrator": "^20.8.3",
+		"@libsql/client": "0.18.0",
 		"@simple-dom/document": "^1.4.0",
 		"@simple-dom/serializer": "^1.4.0",
 		"@simple-dom/void-map": "^1.4.0",
 		"@sinclair/typebox": "0.34.52",
 		"@stylistic/eslint-plugin": "^5.10.0",
 		"@types/bun": "1.3.14",
+		"@types/mssql": "12.3.0",
 		"@types/react": "19.2.0",
 		"@types/react-dom": "19.2.0",
 		"@vue/compiler-sfc": "3.5.27",
@@ -98,6 +100,7 @@
 		"happy-dom": "^20.8.3",
 		"jsonc-parser": "^3.3.1",
 		"less": "4.6.4",
+		"mssql": "12.7.2",
 		"playwright": "^1.59.1",
 		"postcss": "8.5.3",
 		"prettier": "3.5.3",
@@ -331,9 +334,11 @@
 		"@capacitor/cli": "^8.5.0",
 		"@capacitor/core": "^8.5.0",
 		"@capacitor/ios": "^8.5.0",
+		"@libsql/client": ">=0.15.0 <1",
 		"@vue/compiler-sfc": "^3.5.27",
 		"elysia": "^2.0.0-beta.6",
 		"less": "^4.6.0",
+		"mssql": ">=11.0.0 <13",
 		"postcss": "^8.5.0",
 		"react": "^19.2.0",
 		"react-dom": "^19.2.0",
@@ -394,12 +399,18 @@
 		"@capacitor/ios": {
 			"optional": true
 		},
+		"@libsql/client": {
+			"optional": true
+		},
 		"@vue/compiler-sfc": {
 			"optional": true
 		},
 		"less": {
 			"optional": true
 		},
+		"mssql": {
+			"optional": true
+		},
 		"postcss": {
 			"optional": true
 		},
@@ -463,6 +474,7 @@
 		"release:gate": "bun run scripts/releaseGate.ts",
 		"start": "TELEMETRY_OFF=1 bun run src/cli/index.ts start example/server.ts --outdir example/dist --config example/absolute.config.ts",
 		"test": "bun run test:unit && bun run test:integration",
+		"test:db": "bun test tests/integration/cli/db-engines.test.ts",
 		"test:hmr": "bun run scripts/shardedTests.ts tests/integration/hmr",
 		"test:integration": "bun run scripts/shardedTests.ts tests/integration",
 		"test:mobile:update:durable": "ABSOLUTE_TEST_MOBILE_UPDATE_DURABLE=1 bun test tests/integration/mobile-update-durable-conformance.test.ts",
@@ -542,7 +554,7 @@
 			]
 		}
 	},
-	"version": "0.20.0-beta.120",
+	"version": "0.20.0-beta.121",
 	"workspaces": [
 		"tests/fixtures/*",
 		"tests/fixtures/_packages/*"

package/dist/cli/db-tejnwt9j.js

@@ -1,238 +0,0 @@
-// @bun
-import {
-  colors
-} from "./index-8nym68py.js";
-import {
-  UNFOUND_INDEX
-} from "./index-czwrxgdj.js";
-import"./index-mywsk201.js";
-
-// src/cli/scripts/db.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-var {env, spawn, SQL } = globalThis.Bun;
-var BACKUP_FORMAT_VERSION = 1;
-var RESTORE_CHUNK_ROWS = 500;
-var URL_ENV_KEYS = ["DATABASE_URL", "POSTGRES_URL", "DATABASE_URL_UNPOOLED"];
-var JSON_DATA_TYPES = ["json", "jsonb"];
-var SEED_CANDIDATES = ["db/seed.ts", "src/db/seed.ts", "seed.ts"];
-var VALUE_FLAGS = ["--out", "--url", "--only", "--exclude"];
-var paint = (text, color) => `${color}${text}${colors.reset}`;
-var chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size));
-var quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`;
-var resolveUrl = (explicit) => {
-  const found = explicit ?? URL_ENV_KEYS.map((key) => env[key]).find((value) => typeof value === "string" && value !== "");
-  if (found === undefined || found === "")
-    throw new Error(`No database URL found. Set ${URL_ENV_KEYS.join(" or ")}, or pass --url <url>.`);
-  return found;
-};
-var keepTable = (name, options) => (options.only.length === 0 || options.only.includes(name)) && !options.exclude.includes(name);
-var listTables = async (sql) => {
-  const rows = await sql`select table_name from information_schema.tables where table_schema = ${"public"} and table_type = ${"BASE TABLE"} order by table_name`;
-  return rows.map((row) => row.table_name);
-};
-var columnsFor = async (sql, name) => {
-  const rows = await sql.unsafe(`select column_name, data_type from information_schema.columns where table_schema = $1 and table_name = $2 order by ordinal_position`, ["public", name]);
-  return rows.map((row) => ({
-    isJson: JSON_DATA_TYPES.includes(row.data_type),
-    name: row.column_name
-  }));
-};
-var primaryKeyFor = async (sql, name) => {
-  const rows = await sql.unsafe(`select a.attname as col from pg_index i join pg_attribute a on a.attrelid = i.indrelid and a.attnum = any(i.indkey) where i.indrelid = $1::regclass and i.indisprimary order by a.attnum`, [`public.${quoteIdent(name)}`]);
-  return rows.map((row) => row.col);
-};
-var tableMeta = async (sql, name) => {
-  const [columns, primaryKey] = await Promise.all([
-    columnsFor(sql, name),
-    primaryKeyFor(sql, name)
-  ]);
-  return { columns, name, primaryKey };
-};
-var foreignLinks = async (sql) => {
-  const rows = await sql.unsafe(`select tc.table_name as child, ccu.table_name as parent from information_schema.table_constraints tc join information_schema.constraint_column_usage ccu on ccu.constraint_name = tc.constraint_name and ccu.table_schema = tc.table_schema where tc.constraint_type = 'FOREIGN KEY' and tc.table_schema = $1`, ["public"]);
-  return rows.map((row) => ({
-    from: row.child,
-    to: row.parent
-  }));
-};
-var conflictClause = (meta) => {
-  if (meta.primaryKey.length === 0)
-    return "on conflict do nothing";
-  const target = meta.primaryKey.map(quoteIdent).join(", ");
-  const updatable = meta.columns.map((col) => col.name).filter((name) => !meta.primaryKey.includes(name));
-  if (updatable.length === 0)
-    return `on conflict (${target}) do nothing`;
-  const sets = updatable.map((name) => `${quoteIdent(name)} = excluded.${quoteIdent(name)}`).join(", ");
-  return `on conflict (${target}) do update set ${sets}`;
-};
-var dependencyOrder = (names, links) => {
-  const present = new Set(names);
-  const edges = links.filter((link) => present.has(link.from) && present.has(link.to) && link.from !== link.to);
-  const indegree = new Map(names.map((name) => [name, 0]));
-  edges.forEach((link) => indegree.set(link.from, (indegree.get(link.from) ?? 0) + 1));
-  const ready = names.filter((name) => (indegree.get(name) ?? 0) === 0);
-  const ordered = [];
-  const release = (parent) => edges.filter((link) => link.to === parent).forEach((link) => {
-    const next = (indegree.get(link.from) ?? 0) - 1;
-    indegree.set(link.from, next);
-    if (next === 0)
-      ready.push(link.from);
-  });
-  const drain = () => {
-    const head = ready.shift();
-    if (head === undefined)
-      return;
-    ordered.push(head);
-    release(head);
-    drain();
-  };
-  drain();
-  names.forEach((name) => {
-    if (!ordered.includes(name))
-      ordered.push(name);
-  });
-  return ordered;
-};
-var encodeValue = (col, value) => {
-  if (value === null || value === undefined)
-    return null;
-  if (col.isJson)
-    return JSON.stringify(value);
-  return value;
-};
-var insertChunk = async (sql, meta, rows) => {
-  const colNames = meta.columns.map((col) => col.name);
-  const groups = rows.map((_, rowIdx) => {
-    const base = rowIdx * colNames.length;
-    const slots = [...colNames.keys()].map((colIdx) => `$${base + colIdx + 1}`);
-    return `(${slots.join(", ")})`;
-  });
-  const params = rows.flatMap((row) => meta.columns.map((col) => encodeValue(col, row[col.name])));
-  const columnList = colNames.map(quoteIdent).join(", ");
-  const query = `insert into ${quoteIdent(meta.name)} (${columnList}) values ${groups.join(", ")} ${conflictClause(meta)}`;
-  await sql.unsafe(query, params);
-};
-var restoreTable = async (sql, meta, rows) => {
-  if (meta === undefined || rows.length === 0)
-    return;
-  await chunkRows(rows, RESTORE_CHUNK_ROWS).reduce(async (prev, part) => {
-    await prev;
-    return insertChunk(sql, meta, part);
-  }, Promise.resolve());
-};
-var truncateAll = async (sql, names) => {
-  if (names.length === 0)
-    return;
-  const list = names.map(quoteIdent).join(", ");
-  await sql.unsafe(`truncate ${list} restart identity cascade`);
-};
-var runBackup = async (options) => {
-  const sql = new SQL(options.url);
-  const chosen = (await listTables(sql)).filter((name) => keepTable(name, options));
-  const dumps = await Promise.all(chosen.map(async (name) => {
-    const rows = await sql.unsafe(`select * from ${quoteIdent(name)}`);
-    return [name, rows];
-  }));
-  await sql.end();
-  const tables = Object.fromEntries(dumps);
-  const payload = {
-    at: new Date().toISOString(),
-    tables,
-    v: BACKUP_FORMAT_VERSION
-  };
-  const dir = options.out ?? join(process.cwd(), "backups");
-  mkdirSync(dir, { recursive: true });
-  const json = JSON.stringify(payload, (_, value) => typeof value === "bigint" ? value.toString() : value);
-  const file = join(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
-  writeFileSync(file, json);
-  writeFileSync(join(dir, "latest.json"), json);
-  const total = chosen.reduce((sum, name) => sum + (tables[name]?.length ?? 0), 0);
-  console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
-  console.log(paint(`  ${chosen.length} tables, ${total} rows`, colors.dim));
-};
-var runRestore = async (file, options) => {
-  if (!existsSync(file))
-    throw new Error(`Backup not found: ${file}`);
-  const payload = JSON.parse(readFileSync(file, "utf-8"));
-  const names = Object.keys(payload.tables).filter((name) => keepTable(name, options));
-  const sql = new SQL(options.url);
-  const order = dependencyOrder(names, await foreignLinks(sql));
-  const metas = await Promise.all(order.map((name) => tableMeta(sql, name)));
-  const metaByName = new Map(metas.map((meta) => [meta.name, meta]));
-  const aborted = options.truncate && !options.yes && prompt(paint(`\u26A0 TRUNCATE ${order.length} tables before restore? type "yes": `, colors.yellow)) !== "yes";
-  if (aborted) {
-    await sql.end();
-    console.log(paint("aborted", colors.yellow));
-    return;
-  }
-  if (options.truncate)
-    await truncateAll(sql, [...order].reverse());
-  await order.reduce(async (prev, name) => {
-    await prev;
-    return restoreTable(sql, metaByName.get(name), payload.tables[name] ?? []);
-  }, Promise.resolve());
-  await sql.end();
-  const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
-  console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
-};
-var runSeed = async (entry) => {
-  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync(join(process.cwd(), candidate)));
-  if (target === undefined)
-    throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
-  console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
-  const proc = spawn(["bun", "run", target], {
-    stderr: "inherit",
-    stdin: "inherit",
-    stdout: "inherit"
-  });
-  const code = await proc.exited;
-  if (code !== 0)
-    throw new Error(`Seed failed (exit ${code}).`);
-};
-var flagValue = (rest, flag) => {
-  const idx = rest.indexOf(flag);
-  return idx === UNFOUND_INDEX ? undefined : rest[idx + 1];
-};
-var listValue = (rest, flag) => (flagValue(rest, flag) ?? "").split(",").map((part) => part.trim()).filter((part) => part !== "");
-var parseOptions = (rest) => ({
-  exclude: listValue(rest, "--exclude"),
-  only: listValue(rest, "--only"),
-  out: flagValue(rest, "--out"),
-  truncate: rest.includes("--truncate"),
-  url: resolveUrl(flagValue(rest, "--url")),
-  yes: rest.includes("--yes") || rest.includes("-y")
-});
-var positionalArgs = (rest) => rest.filter((arg, idx) => !arg.startsWith("-") && !VALUE_FLAGS.includes(rest[idx - 1] ?? ""));
-var usage = () => {
-  console.error("Usage: absolute db <backup|restore|seed> [options]");
-  console.error("  backup  [--out <dir>] [--only a,b] [--exclude a,b] [--url <url>]   Dump tables \u2192 JSON (+ latest.json)");
-  console.error("  restore [file] [--truncate] [--only a,b] [--exclude a,b] [-y]      Idempotent upsert by primary key");
-  console.error("  seed    [file]                                                     Run the project\u2019s seed script");
-  process.exit(1);
-};
-var runDb = async (args) => {
-  const [sub, ...rest] = args;
-  if (sub === "backup") {
-    await runBackup(parseOptions(rest));
-    return;
-  }
-  if (sub === "restore") {
-    const file = positionalArgs(rest)[0] ?? join(process.cwd(), "backups", "latest.json");
-    await runRestore(file, parseOptions(rest));
-    return;
-  }
-  if (sub === "seed") {
-    await runSeed(positionalArgs(rest)[0]);
-    return;
-  }
-  usage();
-};
-export {
-  chunkRows,
-  conflictClause,
-  dependencyOrder,
-  encodeValue,
-  quoteIdent,
-  runDb
-};