katecms 0.0.0-stage → 1.0.0-beta.1

package/dist/runtime/server/api/uploads/[...key].get.js

@@ -0,0 +1,28 @@
+import { createError, defineEventHandler, getRequestURL, setHeader } from "h3";
+import { getMediaStorage } from "../../utils/media.js";
+import { uploadResponseHeaders } from "../../utils/upload-headers.js";
+export default defineEventHandler(async (event) => {
+  const pathname = getRequestURL(event).pathname;
+  const prefix = "/uploads/";
+  if (!pathname.startsWith(prefix)) {
+    throw createError({ statusCode: 404, statusMessage: "File not found." });
+  }
+  const key = decodeURIComponent(pathname.slice(prefix.length));
+  const storage = getMediaStorage();
+  let data;
+  try {
+    if (!key || !await storage.exists(key)) {
+      throw createError({ statusCode: 404, statusMessage: "File not found." });
+    }
+    data = await storage.get(key);
+  } catch (error) {
+    if (error && typeof error === "object" && "statusCode" in error) {
+      throw error;
+    }
+    throw createError({ statusCode: 404, statusMessage: "File not found." });
+  }
+  for (const [name, value] of Object.entries(uploadResponseHeaders(key))) {
+    setHeader(event, name, value);
+  }
+  return data;
+});

package/dist/runtime/server/kit.d.ts

@@ -0,0 +1,5 @@
+export { getDb } from './utils/db.js';
+export { requireUser } from './utils/session.js';
+export { requireEntryPermission, requirePermission } from './utils/permissions.js';
+export { clientAddress, trustedProxyHops } from './utils/client-address.js';
+export { eventClientAddress } from './utils/request-address.js';

package/dist/runtime/server/kit.js

@@ -0,0 +1,5 @@
+export { getDb } from "./utils/db.js";
+export { requireUser } from "./utils/session.js";
+export { requireEntryPermission, requirePermission } from "./utils/permissions.js";
+export { clientAddress, trustedProxyHops } from "./utils/client-address.js";
+export { eventClientAddress } from "./utils/request-address.js";

package/dist/runtime/server/middleware/admin-headers.d.ts

@@ -0,0 +1,3 @@
+/** Keep the admin shell out of foreign frames and stop MIME sniffing. */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, void>;
+export default _default;

package/dist/runtime/server/middleware/admin-headers.js

@@ -0,0 +1,12 @@
+import { appendResponseHeader, defineEventHandler, getRequestURL, setResponseHeader } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { isCmsAdminPath } from "../../utils/cms-paths.js";
+export default defineEventHandler((event) => {
+  const adminPath = String(useRuntimeConfig().katecms?.adminPath || "admin");
+  const path = getRequestURL(event).pathname;
+  if (!isCmsAdminPath(path, adminPath)) {
+    return;
+  }
+  setResponseHeader(event, "X-Content-Type-Options", "nosniff");
+  appendResponseHeader(event, "Content-Security-Policy", "frame-ancestors 'none'");
+});

package/dist/runtime/server/plugins/auto-migrate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/auto-migrate.js

@@ -0,0 +1,45 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { useRuntimeConfig } from "#imports";
+import {
+  createPostgresDb,
+  migratePostgres,
+  migrateSqlite,
+  resolveDatabaseTarget,
+  syncCollectionFieldIndexes
+} from "@katecms/core";
+function trimEnv(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+export default defineNitroPlugin(async () => {
+  const katecms = useRuntimeConfig().katecms;
+  const database = katecms?.database;
+  const driver = trimEnv(database?.driver);
+  const url = trimEnv(database?.url) || (driver === "postgres" ? trimEnv(process.env.DATABASE_URL) : "");
+  const target = resolveDatabaseTarget({
+    driver,
+    url,
+    sqliteFilename: database?.sqliteFilename
+  });
+  if (target.driver === "postgres") {
+    await migratePostgres(target.url);
+    const db = createPostgresDb(target.url);
+    try {
+      const result = await syncCollectionFieldIndexes(
+        db,
+        katecms?.collections ?? {}
+      );
+      for (const warning of result.warnings) {
+        console.warn(`[KateCMS] ${warning}`);
+      }
+      if (result.created.length > 0 || result.dropped.length > 0) {
+        console.info(
+          `[KateCMS] Field indexes: created ${result.created.length}, dropped ${result.dropped.length}`
+        );
+      }
+    } finally {
+      await db.destroy();
+    }
+    return;
+  }
+  await migrateSqlite({ filename: target.filename });
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/server/utils/auth-attempts.d.ts

@@ -0,0 +1,22 @@
+import type { AuthRateLimitDecision } from '@katecms/core';
+export interface AuthAttemptKeys {
+    /** Action, address, and email. Cleared after a successful attempt. */
+    pair: string;
+    /** Action and address. Stays after success so one login does not reopen the address. */
+    ip: string;
+    /** Action and email. Cleared after a successful attempt. */
+    email: string;
+}
+/**
+ * Three buckets for one login or registration attempt.
+ * Empty addresses and emails share an `unknown` bucket.
+ */
+export declare function authAttemptKeys(action: 'login' | 'register', ip: string, email: string): AuthAttemptKeys;
+/** Longest cooldown among the given buckets, or 0 when every bucket allows the attempt. */
+export declare function authAttemptRetryAfterMs(key: string | AuthAttemptKeys): number;
+export declare function recordAuthAttemptFailure(key: string | AuthAttemptKeys): AuthRateLimitDecision;
+/**
+ * Drop the email and pair buckets. An address bucket is left in place.
+ * A string key (password change) is cleared on its own.
+ */
+export declare function recordAuthAttemptSuccess(key: string | AuthAttemptKeys): void;

package/dist/runtime/server/utils/auth-attempts.js

@@ -0,0 +1,42 @@
+import { createAuthRateLimiter } from "@katecms/core";
+const limiter = createAuthRateLimiter();
+export function authAttemptKeys(action, ip, email) {
+  const address = ip.trim() || "unknown";
+  const normalized = email.trim().toLowerCase() || "unknown";
+  return {
+    pair: `${action}:pair:${address}:${normalized}`,
+    ip: `${action}:ip:${address}`,
+    email: `${action}:email:${normalized}`
+  };
+}
+function asKeys(key) {
+  return typeof key === "string" ? [key] : [key.pair, key.ip, key.email];
+}
+export function authAttemptRetryAfterMs(key) {
+  let retryAfterMs = 0;
+  for (const item of asKeys(key)) {
+    const decision = limiter.check(item);
+    if (!decision.allowed) {
+      retryAfterMs = Math.max(retryAfterMs, decision.retryAfterMs);
+    }
+  }
+  return retryAfterMs;
+}
+export function recordAuthAttemptFailure(key) {
+  let longest = { allowed: true, retryAfterMs: 0 };
+  for (const item of asKeys(key)) {
+    const decision = limiter.recordFailure(item);
+    if (decision.retryAfterMs > longest.retryAfterMs) {
+      longest = decision;
+    }
+  }
+  return longest;
+}
+export function recordAuthAttemptSuccess(key) {
+  if (typeof key === "string") {
+    limiter.recordSuccess(key);
+    return;
+  }
+  limiter.recordSuccess(key.pair);
+  limiter.recordSuccess(key.email);
+}

package/dist/runtime/server/utils/auth-rate-limit.d.ts

@@ -0,0 +1,11 @@
+import type { H3Event } from 'h3';
+import { authAttemptKeys, recordAuthAttemptFailure, recordAuthAttemptSuccess } from './auth-attempts.js';
+import type { AuthAttemptKeys } from './auth-attempts.js';
+export { authAttemptKeys, recordAuthAttemptFailure, recordAuthAttemptSuccess };
+export type { AuthAttemptKeys };
+export declare function getAuthAttemptKeys(event: H3Event, action: 'login' | 'register', email: string): AuthAttemptKeys;
+export declare function assertAuthAttemptAllowed(event: H3Event, key: string | AuthAttemptKeys): void;
+export declare function throwTooManyAttempts(event: H3Event, retryAfterMs: number): never;
+export declare function invalidCredentialsError(retryAfterMs?: number): import("h3").H3Error<{
+    retryAfterMs: number;
+}>;

package/dist/runtime/server/utils/auth-rate-limit.js

@@ -0,0 +1,36 @@
+import { createError, setHeader } from "h3";
+import {
+  authAttemptKeys,
+  authAttemptRetryAfterMs,
+  recordAuthAttemptFailure,
+  recordAuthAttemptSuccess
+} from "./auth-attempts.js";
+import { eventClientAddress } from "./request-address.js";
+export { authAttemptKeys, recordAuthAttemptFailure, recordAuthAttemptSuccess };
+export function getAuthAttemptKeys(event, action, email) {
+  return authAttemptKeys(action, eventClientAddress(event), email);
+}
+export function assertAuthAttemptAllowed(event, key) {
+  const retryAfterMs = authAttemptRetryAfterMs(key);
+  if (retryAfterMs > 0) {
+    throwTooManyAttempts(event, retryAfterMs);
+  }
+}
+export function throwTooManyAttempts(event, retryAfterMs) {
+  const retryAfterSec = Math.max(1, Math.ceil(retryAfterMs / 1e3));
+  setHeader(event, "Retry-After", retryAfterSec);
+  throw createError({
+    statusCode: 429,
+    statusMessage: "Too Many Requests",
+    message: `Too many attempts. Try again in ${retryAfterSec} sec.`,
+    data: { retryAfterMs }
+  });
+}
+export function invalidCredentialsError(retryAfterMs = 0) {
+  return createError({
+    statusCode: 401,
+    statusMessage: "Unauthorized",
+    message: "Invalid email or password.",
+    data: { retryAfterMs }
+  });
+}

package/dist/runtime/server/utils/client-address.d.ts

@@ -0,0 +1,16 @@
+/**
+ * How many reverse proxies may append to `X-Forwarded-For`.
+ * `MIRAICMS_TRUST_PROXY=1` trusts one proxy and uses the address it added.
+ * Unset means the header is ignored and the socket address is used.
+ */
+export declare function trustedProxyHops(raw?: string | undefined): number;
+/**
+ * Client address for the auth limiter.
+ * With `hops` 0 the forwarded header is ignored, so a caller cannot pick a new
+ * bucket by sending another `X-Forwarded-For`.
+ */
+export declare function clientAddress(options: {
+    forwardedFor?: string | null;
+    hops: number;
+    socketAddress?: string | null;
+}): string;

package/dist/runtime/server/utils/client-address.js

@@ -0,0 +1,23 @@
+export function trustedProxyHops(raw = process.env.MIRAICMS_TRUST_PROXY) {
+  const value = (raw ?? "").trim().toLowerCase();
+  if (!value || value === "0" || value === "false" || value === "off") {
+    return 0;
+  }
+  if (value === "true" || value === "on") {
+    return 1;
+  }
+  const hops = Number(value);
+  if (!Number.isInteger(hops) || hops < 1) {
+    return 0;
+  }
+  return hops;
+}
+export function clientAddress(options) {
+  const socket = options.socketAddress?.trim() || "unknown";
+  if (options.hops < 1) {
+    return socket;
+  }
+  const parts = (options.forwardedFor ?? "").split(",").map((part) => part.trim()).filter(Boolean);
+  const index = parts.length - options.hops;
+  return index >= 0 && parts[index] ? parts[index] : socket;
+}

package/dist/runtime/server/utils/collections.d.ts

@@ -0,0 +1,42 @@
+import { findUserById } from '@katecms/core';
+import type { Collection, CollectionDefinition, CollectionListStatus, CollectionParentOption, CollectionStatus, Collections, RoleMap, SafeUser } from '@katecms/core';
+import type { AdminCollectionMeta, AdminEntry, ParentOption, PublicDictionaryTerm } from '../../utils/collections.js';
+export declare function fail(statusCode: number, message: string): never;
+export declare function getCollections(): Collections;
+export declare function getCollectionDefinition(slug: string): CollectionDefinition | undefined;
+export declare function requireCollection(slug: string): CollectionDefinition;
+export declare function toCollectionMeta(slug: string, def: CollectionDefinition): AdminCollectionMeta;
+export declare function collectionRevisionsEnabled(def: CollectionDefinition): boolean;
+export declare function toAdminEntry(row: Collection, slugPath: string, flags?: {
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    depth?: number;
+    authorName?: string | null;
+    dictionaryIds?: Record<string, number[]>;
+    dictionaries?: Record<string, PublicDictionaryTerm[]>;
+}): AdminEntry;
+export declare function entryFlags(actor: SafeUser, row: Collection, roles: RoleMap): {
+    canUpdate: boolean;
+    canDelete: boolean;
+};
+export declare function toParentOption(row: CollectionParentOption): ParentOption;
+export declare function readCollectionSlug(raw: string | undefined): string;
+export declare function readEntryId(raw: string | undefined): number;
+export declare function readTitle(value: unknown): string;
+export declare function readSlug(value: unknown): string;
+export declare function readStatus(value: unknown, fallback?: CollectionStatus): CollectionStatus;
+export declare function readFields(value: unknown): Record<string, unknown>;
+/** Reject published entries that are missing visible required fields. */
+export declare function requirePublishedFields(def: CollectionDefinition, status: CollectionStatus, fields: Record<string, unknown>): void;
+export declare function readParentId(value: unknown): number | null;
+export declare function readAuthorId(value: unknown): number;
+/** Resolve `authorId` from the request. Assigning another user requires `users:read`. */
+export declare function resolveAuthorId(db: Parameters<typeof findUserById>[0], actor: SafeUser, roles: RoleMap, requested: unknown, fallback: number): Promise<number>;
+export declare function readMenuOrder(value: unknown, fallback?: number): number;
+/** `undefined` = omit from patch; `null` = clear. */
+export declare function readPublishedAt(value: unknown): Date | null | undefined;
+export declare function readListStatus(value: unknown): CollectionListStatus;
+export declare function readPage(value: unknown): number;
+export declare function readPerPage(value: unknown, fallback?: number): number;
+export declare function readSearch(value: unknown): string;
+export declare function rethrowCollectionWriteError(error: unknown): never;

package/dist/runtime/server/utils/collections.js

@@ -0,0 +1,300 @@
+import { createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+import {
+  can,
+  canOnEntry,
+  collectionPerPage,
+  DEFAULT_COLLECTION_PER_PAGE,
+  findUserById,
+  formatRequiredFieldsError,
+  isUniqueConstraintError,
+  parseDate,
+  UNLIMITED_COLLECTION_PER_PAGE,
+  validateRequiredFields
+} from "@katecms/core";
+const ENTRY_STATUSES = ["published", "draft", "trash"];
+const LIST_STATUSES = ["published", "draft", "trash", "active", "all"];
+const SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/i;
+const STATUS_PHRASE = {
+  400: "Bad Request",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Conflict",
+  422: "Unprocessable Entity"
+};
+export function fail(statusCode, message) {
+  throw createError({
+    statusCode,
+    statusMessage: STATUS_PHRASE[statusCode] ?? "Error",
+    message
+  });
+}
+export function getCollections() {
+  return useRuntimeConfig().katecms?.collections ?? {};
+}
+export function getCollectionDefinition(slug) {
+  return getCollections()[slug];
+}
+export function requireCollection(slug) {
+  const collection = getCollectionDefinition(slug);
+  if (!collection) {
+    fail(404, "Collection not found.");
+  }
+  return collection;
+}
+export function toCollectionMeta(slug, def) {
+  return {
+    slug,
+    labels: {
+      name: def.labels.name,
+      singularName: def.labels.singularName ?? def.labels.name
+    },
+    hierarchical: def.hierarchical === true,
+    autosave: def.autosave === true,
+    revisions: def.revisions !== false,
+    public: def.public !== false,
+    has_archive: typeof def.has_archive === "string" ? def.has_archive : def.has_archive === true,
+    perPage: collectionPerPage(def),
+    rewrite: def.rewrite,
+    fields: def.fields ?? {}
+  };
+}
+export function collectionRevisionsEnabled(def) {
+  return def.revisions !== false;
+}
+function toIso(value) {
+  if (value == null) {
+    return null;
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+export function toAdminEntry(row, slugPath, flags) {
+  return {
+    id: row.id,
+    type: row.type,
+    status: row.status,
+    slug: row.slug,
+    slugPath: slugPath || row.slug,
+    title: row.title,
+    fields: row.fields ?? {},
+    parentId: row.parent_id,
+    menuOrder: row.menu_order,
+    authorId: row.author_id,
+    createdAt: toIso(row.created_at) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    updatedAt: toIso(row.updated_at) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    publishedAt: toIso(row.published_at),
+    ...flags
+  };
+}
+export function entryFlags(actor, row, roles) {
+  const entry = { authorId: row.author_id };
+  return {
+    canUpdate: canOnEntry(actor, "collections", "update", entry, {
+      roles,
+      scope: row.type,
+      userId: actor.id
+    }),
+    canDelete: canOnEntry(actor, "collections", "delete", entry, {
+      roles,
+      scope: row.type,
+      userId: actor.id
+    })
+  };
+}
+export function toParentOption(row) {
+  return {
+    id: row.id,
+    title: row.title,
+    slug: row.slug,
+    parentId: row.parentId,
+    slugPath: row.slugPath,
+    depth: row.depth
+  };
+}
+export function readCollectionSlug(raw) {
+  const slug = typeof raw === "string" ? raw.trim() : "";
+  if (!slug) {
+    fail(400, "Collection is required.");
+  }
+  return slug;
+}
+export function readEntryId(raw) {
+  const id = Number(raw);
+  if (!Number.isInteger(id) || id <= 0) {
+    fail(400, "Invalid entry id.");
+  }
+  return id;
+}
+export function readTitle(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    fail(422, "Title is required.");
+  }
+  return value.trim();
+}
+export function readSlug(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    fail(422, "Slug is required.");
+  }
+  const slug = value.trim();
+  if (!SLUG_PATTERN.test(slug)) {
+    fail(422, "Slug may contain only letters, numbers, and hyphens.");
+  }
+  return slug;
+}
+export function readStatus(value, fallback = "draft") {
+  if (value === void 0 || value === null || value === "") {
+    return fallback;
+  }
+  if (typeof value !== "string" || !ENTRY_STATUSES.includes(value)) {
+    fail(422, "Invalid status.");
+  }
+  return value;
+}
+export function readFields(value) {
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    fail(422, "Invalid field values.");
+  }
+  return value;
+}
+export function requirePublishedFields(def, status, fields) {
+  if (status !== "published") {
+    return;
+  }
+  const issues = validateRequiredFields(def.fields ?? {}, fields);
+  if (issues.length > 0) {
+    fail(422, formatRequiredFieldsError(issues));
+  }
+}
+export function readParentId(value) {
+  if (value === void 0 || value === null || value === "") {
+    return null;
+  }
+  const id = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(id) || id <= 0) {
+    fail(422, "Invalid parent.");
+  }
+  return id;
+}
+export function readAuthorId(value) {
+  const id = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(id) || id <= 0) {
+    fail(422, "Invalid author.");
+  }
+  return id;
+}
+export async function resolveAuthorId(db, actor, roles, requested, fallback) {
+  if (requested === void 0 || requested === null || requested === "") {
+    return fallback;
+  }
+  const id = readAuthorId(requested);
+  if (id === fallback) {
+    return id;
+  }
+  if (id !== actor.id && !can(actor, "users", "read", { roles })) {
+    fail(403, "Insufficient permissions.");
+  }
+  const user = await findUserById(db, id);
+  if (!user) {
+    fail(422, "Author not found.");
+  }
+  return id;
+}
+export function readMenuOrder(value, fallback = 0) {
+  if (value === void 0 || value === null || value === "") {
+    return fallback;
+  }
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(n)) {
+    fail(422, "Invalid menu order.");
+  }
+  return n;
+}
+export function readPublishedAt(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null || value === "") {
+    return null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  if (typeof value === "string") {
+    const iso = new Date(value);
+    if (!Number.isNaN(iso.getTime())) {
+      return iso;
+    }
+    const parsed = parseDate(value, "YYYY-MM-DD HH:mm") ?? parseDate(value, "YYYY-MM-DD");
+    if (parsed) {
+      return parsed;
+    }
+  }
+  fail(422, "Invalid publish date.");
+}
+export function readListStatus(value) {
+  if (value === void 0 || value === null || value === "") {
+    return "active";
+  }
+  if (value === "all") {
+    return "active";
+  }
+  if (typeof value === "string" && LIST_STATUSES.includes(value)) {
+    return value;
+  }
+  fail(400, "Invalid status filter.");
+}
+export function readPage(value) {
+  if (value === void 0 || value === null || value === "") {
+    return 1;
+  }
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1) {
+    fail(400, "Invalid page.");
+  }
+  return n;
+}
+export function readPerPage(value, fallback = DEFAULT_COLLECTION_PER_PAGE) {
+  if (value === void 0 || value === null || value === "") {
+    if (fallback === UNLIMITED_COLLECTION_PER_PAGE) {
+      return UNLIMITED_COLLECTION_PER_PAGE;
+    }
+    if (!Number.isInteger(fallback) || fallback < 1) {
+      return DEFAULT_COLLECTION_PER_PAGE;
+    }
+    return fallback;
+  }
+  const n = Number(value);
+  if (n === UNLIMITED_COLLECTION_PER_PAGE) {
+    return UNLIMITED_COLLECTION_PER_PAGE;
+  }
+  if (!Number.isInteger(n) || n < 1) {
+    fail(400, "Invalid page size.");
+  }
+  return n;
+}
+export function readSearch(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim().slice(0, 200);
+}
+export function rethrowCollectionWriteError(error) {
+  if (isUniqueConstraintError(error)) {
+    fail(409, "An entry with this slug already exists.");
+  }
+  const message = error instanceof Error ? error.message : "";
+  if (/parent/i.test(message) || /descendant/i.test(message) || /hierarchy/i.test(message)) {
+    fail(422, message.startsWith("collections:") ? "Invalid parent entry." : message);
+  }
+  throw error;
+}

package/dist/runtime/server/utils/db.d.ts

@@ -0,0 +1,3 @@
+import { createSqliteDb } from '@katecms/core';
+/** Singleton Kysely client for Nitro handlers. */
+export declare function getDb(): ReturnType<typeof createSqliteDb>;

package/dist/runtime/server/utils/db.js

@@ -0,0 +1,25 @@
+import { useRuntimeConfig } from "#imports";
+import {
+  createPostgresDb,
+  createSqliteDb,
+  resolveDatabaseTarget
+} from "@katecms/core";
+let db;
+function trimEnv(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+export function getDb() {
+  if (db) {
+    return db;
+  }
+  const database = useRuntimeConfig().katecms?.database;
+  const driver = trimEnv(database?.driver);
+  const url = trimEnv(database?.url) || (driver === "postgres" ? trimEnv(process.env.DATABASE_URL) : "");
+  const target = resolveDatabaseTarget({
+    driver,
+    url,
+    sqliteFilename: database?.sqliteFilename
+  });
+  db = target.driver === "postgres" ? createPostgresDb(target.url) : createSqliteDb({ filename: target.filename });
+  return db;
+}