@sidebase/base-config 0.1.0

package/dist/eslint/index.mjs

@@ -0,0 +1,278 @@
+import antfu from '@antfu/eslint-config';
+
+const DEFAULT_TEST_FILE_PATTERN = ["**/*.{test,spec}.{ts,tsx}", "**/*.stories.{ts,tsx}"];
+function isNonEmpty(value) {
+  return value.length > 0;
+}
+function resolveConsole(value) {
+  if (value === void 0 || value === "error" || !isNonEmpty(value)) {
+    return "error";
+  }
+  return value;
+}
+function isTypeAware() {
+  return process.env.LINT_TYPEAWARE === "true";
+}
+function resolveEslintOptions(options = {}) {
+  return {
+    zod: options.zod ?? "none",
+    console: resolveConsole(options.console),
+    trpcGuard: options.trpcGuard ?? false,
+    prismaImportGuard: options.prismaImportGuard ?? false,
+    typeDefStyle: options.typeDefStyle ?? "interface",
+    autoImportPaths: options.autoImportPaths ?? ["utils/", "composables/", "~~/shared/types/"],
+    autoImportTypeOnly: options.autoImportTypeOnly ?? [],
+    // Both config locations stay listed: streamctl >= 0.2.0 scaffolds
+    // `streamctl.config.ts` in the repo root, but `.streamctl/config.ts` remains a
+    // supported fallback, so a repo can be on either while the fleet migrates.
+    ignoresTypeAware: options.ignoresTypeAware ?? ["prisma.config.ts", "eslint.config.ts", "streamctl.config.ts", ".streamctl/**/*.ts"],
+    testFilePattern: options.testFilePattern ?? DEFAULT_TEST_FILE_PATTERN,
+    typeAware: isTypeAware()
+  };
+}
+
+const TRPC_ROUTERS_GLOB = "**/server/trpc/routers/**/*.{ts,js}";
+const ZOD_DEPRECATED_METHODS = ["extend", "merge", "passthrough"];
+const APP_FILES = ["**/*.{ts,vue}"];
+const APP_IGNORES = ["**/*.d.ts"];
+const PROCESS_ENV_PROPERTY = {
+  object: "process",
+  property: "env",
+  message: "Do not use process.env directly. Define and import env via publicEnv.ts (app/server) or serverEnv.ts (server-only)."
+};
+const PUBLIC_PROCEDURE_SELECTOR = {
+  selector: "Identifier[name='publicProcedure']",
+  message: "publicProcedure is banned in tRPC routers. Use an authenticated procedure."
+};
+function zodMethodBans(options) {
+  if (options.zod !== "full") {
+    return [];
+  }
+  return ZOD_DEPRECATED_METHODS.map((method) => ({
+    selector: `CallExpression[callee.property.name='${method}']`,
+    message: `Zod's .${method}() is banned. Prefer the supported schema-composition alternative.`
+  }));
+}
+const ZOD_SOURCE = "/^zod(\\/.*)?$/";
+const ZOD_CORE_SOURCE = "/^zod(\\/v4|\\/mini|\\/v4-mini)?$/";
+const ZOD_IMPORT_STYLE_MESSAGE = "Use `import * as z from 'zod'` instead of a named `z` import.";
+function zodImportStyleBans(options) {
+  if (options.zod !== "full" && options.zod !== "import-style") {
+    return [];
+  }
+  return [
+    // `import { z } from "zod"` / `import { z as zed } from "zod"`: match on the
+    // imported (source) name, so an alias doesn't dodge the ban. Value imports only.
+    { selector: `ImportDeclaration[source.value=${ZOD_SOURCE}][importKind!='type'] ImportSpecifier[imported.name='z'][importKind!='type']`, message: ZOD_IMPORT_STYLE_MESSAGE },
+    // `import z from "zod"`: default import, core entry points only (locale/util
+    // default imports like `zod/v4/locales/de` are legitimate and must pass).
+    { selector: `ImportDeclaration[source.value=${ZOD_CORE_SOURCE}][importKind!='type'] ImportDefaultSpecifier`, message: ZOD_IMPORT_STYLE_MESSAGE },
+    // `export { z } from "zod"` / `export { z as ... } from "zod"`: re-export of z.
+    { selector: `ExportNamedDeclaration[source.value=${ZOD_SOURCE}][exportKind!='type'] ExportSpecifier[local.name='z'][exportKind!='type']`, message: ZOD_IMPORT_STYLE_MESSAGE }
+  ];
+}
+function anchoredGlobs(rawPath) {
+  const path = rawPath.replace(/\/+$/, "");
+  if (/^(?:[~@#/]|\.{1,2}\/)/.test(path)) {
+    return [`${path}/**`];
+  }
+  return [`~/${path}/**`, `~~/${path}/**`, `@/${path}/**`];
+}
+function importRestrictions(options) {
+  const paths = [
+    { name: "node:process", importNames: ["env", "default"], message: PROCESS_ENV_PROPERTY.message, allowTypeImports: true },
+    { name: "process", importNames: ["env", "default"], message: PROCESS_ENV_PROPERTY.message, allowTypeImports: true }
+  ];
+  const typeOnly = new Set(options.autoImportTypeOnly);
+  const patterns = options.autoImportPaths.map((path) => ({
+    group: anchoredGlobs(path),
+    message: `Do not import from "${path.replace(/\/+$/, "")}" directly. It is provided by Nuxt auto-imports.`,
+    ...typeOnly.has(path) ? { allowTypeImports: true } : {}
+  }));
+  return { paths, patterns };
+}
+function buildEslintLayers(options) {
+  const configs = [];
+  configs.push({
+    name: "sidebase/defaults",
+    rules: {
+      "vue/return-in-computed-property": "off",
+      "curly": ["error", "all"],
+      "style/brace-style": ["error", "1tbs"],
+      "comma-dangle": ["error", {
+        arrays: "always-multiline",
+        objects: "always-multiline",
+        functions: "always-multiline",
+        exports: "always-multiline",
+        imports: "always-multiline"
+      }],
+      "space-infix-ops": ["error"],
+      // `node/prefer-global/process` is NOT set here: antfu 7.4.3 registers
+      // eslint-plugin-n (`node`) only inside its own files-scoped object, so setting
+      // the rule in this plugin-less layer makes ESLint 10 ABORT. It is instead
+      // neutralized to `"off"` via `.override("antfu/node/rules")` in
+      // `createSidebaseEslint`, inside antfu's node-scoped object where the plugin
+      // is registered (see the comment there). The `no-restricted-properties`
+      // process.env ban below carries the real guard.
+      "no-unused-expressions": ["error"],
+      "no-param-reassign": ["error"],
+      "no-fallthrough": ["error"],
+      "require-await": ["error"],
+      "ts/no-non-null-assertion": ["error"],
+      // antfu leaves `ts/no-explicit-any` off; this baseline enforces it, matching the
+      // shipped `AGENTS.md` ban on `any`. Breaking for consumers (Q5, Option A).
+      "ts/no-explicit-any": "error",
+      // Type-aware rules antfu enables that this baseline turns off.
+      "ts/no-misused-promises": "off",
+      "ts/no-unsafe-call": "off",
+      "ts/strict-boolean-expressions": "off",
+      "ts/promise-function-async": "off",
+      // Newer antfu rules outside the established house baseline. `prefer-static-regex`
+      // is a perf nudge the consuming apps never adopted; `custom-event-name-casing`
+      // is actively wrong for naive-ui's kebab `update:*` v-model events. Off by
+      // default; a repo can opt back in via `.append()`.
+      "e18e/prefer-static-regex": "off",
+      "vue/custom-event-name-casing": "off"
+    }
+  });
+  configs.push({
+    name: "sidebase/type-definitions",
+    rules: { "ts/consistent-type-definitions": ["error", options.typeDefStyle] }
+  });
+  configs.push({
+    name: "sidebase/console",
+    // Source files only: antfu's markdown processor lints fenced code
+    // blocks as virtual `*.md/*` files, so an un-scoped `no-console` fires inside
+    // README/doc examples. This carve-out leaves real `.ts`/`.vue`/... enforcement intact.
+    ignores: ["**/*.md/**"],
+    rules: {
+      // Always pass an explicit options object: a severity-only override would
+      // retain antfu's `{ allow: ["warn", "error"] }`. `"error"` (hard-ban)
+      // emits `{}` (no-console's schema rejects an empty `allow` array), which
+      // replaces those options so every `console.*` is banned. An empty
+      // allow-list was normalized to `"error"` in resolveEslintOptions, so the
+      // array branch here is always a non-empty allow-list (no cast needed).
+      "no-console": options.console === "error" ? ["error", {}] : ["error", { allow: options.console }]
+    }
+  });
+  const { paths, patterns } = importRestrictions(options);
+  const appRules = {
+    "no-restricted-properties": ["error", PROCESS_ENV_PROPERTY]
+  };
+  if (paths.length > 0 || patterns.length > 0) {
+    appRules["ts/no-restricted-imports"] = ["error", { paths, patterns }];
+  }
+  configs.push({
+    name: "sidebase/restricted-app",
+    files: APP_FILES,
+    ignores: APP_IGNORES,
+    rules: appRules
+  });
+  const zodSyntax = [...zodImportStyleBans(options), ...zodMethodBans(options)];
+  if (zodSyntax.length > 0) {
+    configs.push({
+      name: "sidebase/restricted-syntax",
+      // Source files only: antfu's markdown processor lints fenced code blocks as
+      // virtual `*.md/*` files, so an un-scoped syntax ban fires inside a doc example
+      // using a banned zod method. Mirrors the sidebase/console carve-out.
+      ignores: ["**/*.md/**"],
+      rules: { "no-restricted-syntax": ["error", ...zodSyntax] }
+    });
+  }
+  if (options.trpcGuard) {
+    configs.push({
+      name: "sidebase/trpc-guard",
+      files: [TRPC_ROUTERS_GLOB],
+      rules: { "no-restricted-syntax": ["error", ...zodSyntax, PUBLIC_PROCEDURE_SELECTOR] }
+    });
+  }
+  if (options.prismaImportGuard) {
+    const prismaPattern = {
+      group: ["~~/prisma/*", "~~/prisma/**"],
+      message: "Do not import the Prisma client on the app side. Use a server-only module."
+    };
+    configs.push({
+      name: "sidebase/prisma-import-guard",
+      files: APP_FILES,
+      ignores: [...APP_IGNORES, "**/server/**"],
+      rules: { "ts/no-restricted-imports": ["error", { paths, patterns: [...patterns, prismaPattern] }] }
+    });
+  }
+  if (options.testFilePattern.length > 0) {
+    configs.push({
+      name: "sidebase/test-overrides",
+      files: options.testFilePattern,
+      rules: {
+        "no-restricted-properties": "off",
+        "no-restricted-imports": "off",
+        "ts/no-restricted-imports": "off"
+      }
+    });
+  }
+  return configs;
+}
+
+const ESLINT_OPTION_KEYS = Object.keys({
+  zod: 0,
+  console: 0,
+  trpcGuard: 0,
+  prismaImportGuard: 0,
+  typeDefStyle: 0,
+  autoImportPaths: 0,
+  autoImportTypeOnly: 0,
+  ignoresTypeAware: 0,
+  testFilePattern: 0
+});
+
+function createSidebaseEslint(options = {}) {
+  const resolved = resolveEslintOptions(options);
+  return antfu(
+    {
+      type: "app",
+      // `local.*` files and directories are personal, git-ignored scratch space
+      // and are never linted.
+      ignores: ["**/local.*", "**/local.*/**"],
+      // Org house style: 2-space indent, single quotes, Vue on,
+      // JSON/YAML linting off (handled elsewhere).
+      stylistic: { indent: 2, quotes: "single" },
+      vue: true,
+      jsonc: false,
+      yaml: false,
+      // Type-aware is gated behind `LINT_TYPEAWARE`; when on, point at the repo
+      // tsconfig and exclude the configured paths from the type-aware program.
+      typescript: resolved.typeAware ? { tsconfigPath: "tsconfig.json", ignoresTypeAware: resolved.ignoresTypeAware } : true
+    },
+    ...buildEslintLayers(resolved)
+  ).override("antfu/node/rules", {
+    // antfu 7.4.3's node layer defaults `node/prefer-global/process` to
+    // `["error", "never"]` (demands `require("process")`), which flags EVERY legit
+    // global `process` use in an ESM Nuxt app (env modules, server plugins, loggers).
+    // Leaving the rule unset is not enough: antfu's `never` then wins in consumer
+    // resolution. Neutralize it HERE, inside antfu's own node-scoped config where the
+    // `node` plugin IS registered; setting it in a plugin-less object makes ESLint 10
+    // abort. `"off"`, not `["error", "always"]`, because `"always"` would wrongly flag
+    // the generated Prisma client's `import * as process from 'node:process'`.
+    //
+    // Note what this does NOT mean. prefer-global is not merely redundant here:
+    // `["error", "always"]` would also close a real hole, because
+    // `no-restricted-properties` keys on the `process.env` MEMBER EXPRESSION, and any
+    // import that renames the binding erases the shape it matches. Measured against
+    // this factory, the property ban alone catches `process.env.X`,
+    // `const { env } = process`, and a default import still named `process`, but NOT
+    // `import { env }`, `import { env as e }`, `import * as proc`, or
+    // `import proc from "node:process"`. Those are closed at the import site instead,
+    // by the `node:process` / `process` entries in `paths` (see `importRestrictions` in
+    // rules.ts): narrower than flipping prefer-global, and free of the Prisma-client
+    // false positive.
+    //
+    // With `importNames: ["env", "default"]` that is now the COMPLETE set, not a sample.
+    // Every way to reach `process.env` is covered by one rule or the other: the member
+    // expression and an un-renamed default import at the USAGE site, and the named,
+    // renamed-named, namespace and renamed-default imports at the IMPORT site. The
+    // un-renamed default being caught at the usage site rather than by the import ban is
+    // the asymmetry that hid the renamed-default hole for two rounds of review.
+    rules: { "node/prefer-global/process": "off" }
+  });
+}
+
+export { ESLINT_OPTION_KEYS, buildEslintLayers, createSidebaseEslint, isTypeAware, resolveEslintOptions };

package/dist/prisma/index.d.mts

@@ -0,0 +1,74 @@
+import { PrismaConfig } from 'prisma/config';
+
+/** The schema-engine datasource override (Prisma 6.19 classic engine). */
+interface SchemaEngineDatasource {
+    url: string;
+    shadowDatabaseUrl?: string;
+}
+/**
+ * Seed the three Prisma connection env vars with localhost dev defaults when UNSET.
+ * This is a deliberate SIDE EFFECT on `env` (defaults to `process.env`). Necessary because
+ * once a `prisma.config.ts` exists Prisma stops auto-loading `.env`, so a schema that
+ * reads `env("DATABASE_URL")` / `env("DIRECT_DATABASE_URL")` would fail at rest.
+ *
+ * Call it (after `import "dotenv/config"`) in the config file so the Prisma CLI runs
+ * with ZERO env; a real `.env`/shell value always wins. `buildPrismaConfig` then reads
+ * the seeded env and derives its direct-connection + shadow datasource.
+ *
+ * TWO paths, not one:
+ * - **Bare, or an explicit `DIRECT_DATABASE_URL`.** Seeds all three. Defaults:
+ *   direct = local postgres, pooled = direct + `pgbouncer=1`, shadow = direct with a
+ *   `/prisma-shadow` database.
+ * - **A real `DATABASE_URL` and no direct URL.** Seeds ONLY `DIRECT_DATABASE_URL`,
+ *   derived from the pooled URL, and returns early. No shadow is seeded on purpose:
+ *   deriving one would name a `/prisma-shadow` database on the production host, which
+ *   Prisma CREATEs and DROPs.
+ *
+ * An empty-string value counts as unset throughout; `docker-compose` produces `""` for an
+ * undefined variable, and treating it as present is how the localhost default used to
+ * reach production.
+ */
+declare function applyPrismaDevEnv(env?: Record<string, string | undefined>): void;
+/**
+ * Strip pooler-only query params from a connection string so the schema engine
+ * gets a usable direct connection. Other params (sslmode, schema, ...) are kept.
+ */
+declare function stripPgbouncerParams(url: string): string;
+/**
+ * Resolve the schema engine's datasource (Pattern B):
+ * - direct URL = `DIRECT_DATABASE_URL`, else `DATABASE_URL` with pgbouncer params stripped;
+ * - shadow DB = `SHADOW_DATABASE_URL` when present.
+ *
+ * Returns `undefined` when neither a direct nor a pooled URL is set, so the
+ * config falls back to the schema's own `datasource` block (e.g. during
+ * `prisma generate` without a database).
+ */
+declare function resolveSchemaEngineDatasource(env: Record<string, string | undefined>): SchemaEngineDatasource | undefined;
+
+/** Alias for Prisma 6.19's `defineConfig` input. */
+type PrismaConfigInput = PrismaConfig;
+interface BuildPrismaConfigOptions {
+    /** Enable the `views` config feature (view SQL under `prisma/views`). */
+    views?: boolean;
+    /** Enable the `typedSql` preview feature (queries under `prisma/sql`). */
+    typedSql?: boolean;
+}
+/**
+ * Build the shared `@sidebase` Prisma config (Prisma 6.19 "Pattern B").
+ * Wrap the result in `defineConfig`:
+ *
+ * ```ts
+ * // prisma.config.ts
+ * import { defineConfig } from "prisma/config";
+ * import { buildPrismaConfig } from "@sidebase/base-config/prisma";
+ * export default defineConfig(buildPrismaConfig({ views: true, typedSql: true }));
+ * ```
+ *
+ * Reads `DATABASE_URL` / `DIRECT_DATABASE_URL` / `SHADOW_DATABASE_URL` (the
+ * schema engine gets a pgbouncer-free direct connection). Prisma 7's changed
+ * config shape is out of scope for v1.
+ */
+declare function buildPrismaConfig(options?: BuildPrismaConfigOptions, env?: Record<string, string | undefined>): PrismaConfig;
+
+export { applyPrismaDevEnv, buildPrismaConfig, resolveSchemaEngineDatasource, stripPgbouncerParams };
+export type { BuildPrismaConfigOptions, PrismaConfigInput, SchemaEngineDatasource };

package/dist/prisma/index.d.ts

@@ -0,0 +1,74 @@
+import { PrismaConfig } from 'prisma/config';
+
+/** The schema-engine datasource override (Prisma 6.19 classic engine). */
+interface SchemaEngineDatasource {
+    url: string;
+    shadowDatabaseUrl?: string;
+}
+/**
+ * Seed the three Prisma connection env vars with localhost dev defaults when UNSET.
+ * This is a deliberate SIDE EFFECT on `env` (defaults to `process.env`). Necessary because
+ * once a `prisma.config.ts` exists Prisma stops auto-loading `.env`, so a schema that
+ * reads `env("DATABASE_URL")` / `env("DIRECT_DATABASE_URL")` would fail at rest.
+ *
+ * Call it (after `import "dotenv/config"`) in the config file so the Prisma CLI runs
+ * with ZERO env; a real `.env`/shell value always wins. `buildPrismaConfig` then reads
+ * the seeded env and derives its direct-connection + shadow datasource.
+ *
+ * TWO paths, not one:
+ * - **Bare, or an explicit `DIRECT_DATABASE_URL`.** Seeds all three. Defaults:
+ *   direct = local postgres, pooled = direct + `pgbouncer=1`, shadow = direct with a
+ *   `/prisma-shadow` database.
+ * - **A real `DATABASE_URL` and no direct URL.** Seeds ONLY `DIRECT_DATABASE_URL`,
+ *   derived from the pooled URL, and returns early. No shadow is seeded on purpose:
+ *   deriving one would name a `/prisma-shadow` database on the production host, which
+ *   Prisma CREATEs and DROPs.
+ *
+ * An empty-string value counts as unset throughout; `docker-compose` produces `""` for an
+ * undefined variable, and treating it as present is how the localhost default used to
+ * reach production.
+ */
+declare function applyPrismaDevEnv(env?: Record<string, string | undefined>): void;
+/**
+ * Strip pooler-only query params from a connection string so the schema engine
+ * gets a usable direct connection. Other params (sslmode, schema, ...) are kept.
+ */
+declare function stripPgbouncerParams(url: string): string;
+/**
+ * Resolve the schema engine's datasource (Pattern B):
+ * - direct URL = `DIRECT_DATABASE_URL`, else `DATABASE_URL` with pgbouncer params stripped;
+ * - shadow DB = `SHADOW_DATABASE_URL` when present.
+ *
+ * Returns `undefined` when neither a direct nor a pooled URL is set, so the
+ * config falls back to the schema's own `datasource` block (e.g. during
+ * `prisma generate` without a database).
+ */
+declare function resolveSchemaEngineDatasource(env: Record<string, string | undefined>): SchemaEngineDatasource | undefined;
+
+/** Alias for Prisma 6.19's `defineConfig` input. */
+type PrismaConfigInput = PrismaConfig;
+interface BuildPrismaConfigOptions {
+    /** Enable the `views` config feature (view SQL under `prisma/views`). */
+    views?: boolean;
+    /** Enable the `typedSql` preview feature (queries under `prisma/sql`). */
+    typedSql?: boolean;
+}
+/**
+ * Build the shared `@sidebase` Prisma config (Prisma 6.19 "Pattern B").
+ * Wrap the result in `defineConfig`:
+ *
+ * ```ts
+ * // prisma.config.ts
+ * import { defineConfig } from "prisma/config";
+ * import { buildPrismaConfig } from "@sidebase/base-config/prisma";
+ * export default defineConfig(buildPrismaConfig({ views: true, typedSql: true }));
+ * ```
+ *
+ * Reads `DATABASE_URL` / `DIRECT_DATABASE_URL` / `SHADOW_DATABASE_URL` (the
+ * schema engine gets a pgbouncer-free direct connection). Prisma 7's changed
+ * config shape is out of scope for v1.
+ */
+declare function buildPrismaConfig(options?: BuildPrismaConfigOptions, env?: Record<string, string | undefined>): PrismaConfig;
+
+export { applyPrismaDevEnv, buildPrismaConfig, resolveSchemaEngineDatasource, stripPgbouncerParams };
+export type { BuildPrismaConfigOptions, PrismaConfigInput, SchemaEngineDatasource };

package/dist/prisma/index.mjs

@@ -0,0 +1,61 @@
+import { withQuery, parseURL, parseQuery, stringifyQuery, stringifyParsedURL } from 'ufo';
+
+const PGBOUNCER_PARAMS = ["pgbouncer", "connection_limit", "pool_timeout", "statement_cache_size"];
+const DEV_DIRECT_URL = "postgres://postgres@localhost:5432/postgres?connection_limit=1";
+function deriveShadowUrl(direct) {
+  return stringifyParsedURL({ ...parseURL(direct), pathname: "/prisma-shadow" });
+}
+function blankToUndefined(value) {
+  return value === void 0 || value.trim() === "" ? void 0 : value;
+}
+function applyPrismaDevEnv(env = process.env) {
+  const declaredDirect = blankToUndefined(env.DIRECT_DATABASE_URL);
+  const declaredPooled = blankToUndefined(env.DATABASE_URL);
+  const declaredShadow = blankToUndefined(env.SHADOW_DATABASE_URL);
+  if (declaredDirect === void 0 && declaredPooled !== void 0) {
+    env.DIRECT_DATABASE_URL = stripPgbouncerParams(declaredPooled);
+    return;
+  }
+  const direct = declaredDirect ?? DEV_DIRECT_URL;
+  env.DIRECT_DATABASE_URL = direct;
+  env.DATABASE_URL = declaredPooled ?? withQuery(direct, { pgbouncer: "1" });
+  env.SHADOW_DATABASE_URL = declaredShadow ?? deriveShadowUrl(direct);
+}
+function stripPgbouncerParams(url) {
+  const parsed = parseURL(url);
+  if (!parsed.search) {
+    return url;
+  }
+  const query = parseQuery(parsed.search);
+  for (const key of PGBOUNCER_PARAMS) {
+    delete query[key];
+  }
+  const search = stringifyQuery(query);
+  parsed.search = search ? `?${search}` : "";
+  return stringifyParsedURL(parsed);
+}
+function resolveSchemaEngineDatasource(env) {
+  const declaredDirect = blankToUndefined(env.DIRECT_DATABASE_URL);
+  const declaredPooled = blankToUndefined(env.DATABASE_URL);
+  const direct = declaredDirect ?? (declaredPooled ? stripPgbouncerParams(declaredPooled) : void 0);
+  if (!direct) {
+    return void 0;
+  }
+  const shadowDatabaseUrl = blankToUndefined(env.SHADOW_DATABASE_URL);
+  return shadowDatabaseUrl ? { url: direct, shadowDatabaseUrl } : { url: direct };
+}
+
+function buildPrismaConfig(options = {}, env = process.env) {
+  const { views = false, typedSql = false } = options;
+  const base = {
+    ...views ? { views: { path: "prisma/views" } } : {},
+    ...typedSql ? { typedSql: { path: "prisma/sql" } } : {}
+  };
+  const datasource = resolveSchemaEngineDatasource(env);
+  if (datasource) {
+    return { ...base, engine: "classic", datasource };
+  }
+  return base;
+}
+
+export { applyPrismaDevEnv, buildPrismaConfig, resolveSchemaEngineDatasource, stripPgbouncerParams };

package/dist/shared/base-config.CuUhyvQo.d.mts

@@ -0,0 +1,47 @@
+/**
+ * Options for the published ESLint factory (`@sidebase/base-config/eslint`).
+ * Covers the per-repo variance found across the consuming repos.
+ */
+interface CreateSidebaseEslintOptions {
+    /** Zod `.extend()/.merge()/.passthrough()` bans and/or `import * as z` enforcement. Default `"none"` (opt-in). */
+    zod?: "full" | "import-style" | "none";
+    /** Allow-list of permitted console methods, or a hard error. Default `"error"`. */
+    console?: string[] | "error";
+    /** Ban `publicProcedure` in `server/trpc/routers/**`. Default `false`. */
+    trpcGuard?: boolean;
+    /** Restrict `~~/prisma/` client imports on the app side. Default `false`. */
+    prismaImportGuard?: boolean;
+    /** `ts/consistent-type-definitions`. Default `"interface"`. */
+    typeDefStyle?: "interface" | "type";
+    /** Paths banned from direct import (Nuxt auto-import). Default `["utils/", "composables/", "~~/shared/types/"]`. */
+    autoImportPaths?: string[];
+    /**
+     * Subset of {@link autoImportPaths} where `import type { ... }` is still allowed
+     * (value imports stay banned), for repos that import a path like `composables/`
+     * only for its types. Default `[]` (opt-in).
+     */
+    autoImportTypeOnly?: string[];
+    /**
+     * Files excluded from antfu's type-aware program (only relevant when
+     * type-aware). Default excludes `prisma.config.ts`, `eslint.config.ts`, the
+     * root `streamctl.config.ts`, and the legacy `.streamctl` TS files (see
+     * `resolveEslintOptions`).
+     */
+    ignoresTypeAware?: string[];
+    /**
+     * Globs for test / spec / story files where the `process.env` + auto-import
+     * bans are relaxed. Defaults to the standard `.test.`/`.spec.`/
+     * `.stories.` `ts`/`tsx` globs (see `resolveEslintOptions`).
+     */
+    testFilePattern?: string[];
+}
+/**
+ * Runtime list of every {@link CreateSidebaseEslintOptions} key, for config
+ * validation/iteration. The `satisfies Record<keyof ..., 0>` map makes this
+ * exhaustive: adding a future option to the interface fails to compile until
+ * the key is listed here too, so the validator allow-list can never drift.
+ */
+declare const ESLINT_OPTION_KEYS: string[];
+
+export { ESLINT_OPTION_KEYS as E };
+export type { CreateSidebaseEslintOptions as C };

package/dist/shared/base-config.CuUhyvQo.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Options for the published ESLint factory (`@sidebase/base-config/eslint`).
+ * Covers the per-repo variance found across the consuming repos.
+ */
+interface CreateSidebaseEslintOptions {
+    /** Zod `.extend()/.merge()/.passthrough()` bans and/or `import * as z` enforcement. Default `"none"` (opt-in). */
+    zod?: "full" | "import-style" | "none";
+    /** Allow-list of permitted console methods, or a hard error. Default `"error"`. */
+    console?: string[] | "error";
+    /** Ban `publicProcedure` in `server/trpc/routers/**`. Default `false`. */
+    trpcGuard?: boolean;
+    /** Restrict `~~/prisma/` client imports on the app side. Default `false`. */
+    prismaImportGuard?: boolean;
+    /** `ts/consistent-type-definitions`. Default `"interface"`. */
+    typeDefStyle?: "interface" | "type";
+    /** Paths banned from direct import (Nuxt auto-import). Default `["utils/", "composables/", "~~/shared/types/"]`. */
+    autoImportPaths?: string[];
+    /**
+     * Subset of {@link autoImportPaths} where `import type { ... }` is still allowed
+     * (value imports stay banned), for repos that import a path like `composables/`
+     * only for its types. Default `[]` (opt-in).
+     */
+    autoImportTypeOnly?: string[];
+    /**
+     * Files excluded from antfu's type-aware program (only relevant when
+     * type-aware). Default excludes `prisma.config.ts`, `eslint.config.ts`, the
+     * root `streamctl.config.ts`, and the legacy `.streamctl` TS files (see
+     * `resolveEslintOptions`).
+     */
+    ignoresTypeAware?: string[];
+    /**
+     * Globs for test / spec / story files where the `process.env` + auto-import
+     * bans are relaxed. Defaults to the standard `.test.`/`.spec.`/
+     * `.stories.` `ts`/`tsx` globs (see `resolveEslintOptions`).
+     */
+    testFilePattern?: string[];
+}
+/**
+ * Runtime list of every {@link CreateSidebaseEslintOptions} key, for config
+ * validation/iteration. The `satisfies Record<keyof ..., 0>` map makes this
+ * exhaustive: adding a future option to the interface fails to compile until
+ * the key is listed here too, so the validator allow-list can never drift.
+ */
+declare const ESLINT_OPTION_KEYS: string[];
+
+export { ESLINT_OPTION_KEYS as E };
+export type { CreateSidebaseEslintOptions as C };