@drzl/validation-core 1.1.0 → 2.1.0

package/README.md

@@ -37,3 +37,23 @@ Shared interfaces and helpers used by validation generators.
 - Helpers
   - `insertColumns(table)`, `updateColumns(table)`, `selectColumns(table)`
   - `formatCode(code, filePath, formatOpts)`
+- File names (shared by every generator that writes a file and a barrel)
+  - `moduleFileName(tsName, fileSuffix)` -> `users.zod.ts`
+  - `moduleSpecifier(tsName, fileSuffix, importExtension?)` -> `./users.zod.js`, the
+    specifier a sibling module needs to import that file.
+  - `importSpecifier(relativePath, importExtension?)` does the same for a path a generator
+    already has in hand, e.g. `./types/users.ts` -> `./types/users.js`.
+  - Both read the same `fileSuffix`, so a barrel can never name a file that was not written.
+  - `ImportExtension` is `'js' | 'none' | 'ts'`, defaulting to `DEFAULT_IMPORT_EXTENSION`
+    (`'js'`). `'js'` is the only form that resolves under `bundler`, `node10`, `node16` and
+    `nodenext`, in both CommonJS and ESM, with no compiler flag. `'none'` is the pre-2.0
+    output and misses `node16`/`nodenext` ES modules. `'ts'` needs
+    `allowImportingTsExtensions`. `.mts` and `.cts` become `.mjs` and `.cjs` under both
+    `'js'` and `'none'`, since an extensionless specifier never resolves to them.
+- Naming (shared by every generator that emits a schema name)
+  - `resolveAffix({ affix, schemaSuffix })` -> `ResolvedAffix`
+  - `schemaName(mode, tsName, resolved)`, `typeName(mode, tsName, resolved)`
+  - `validateAffix(affix, schemaSuffix)` -> issues for unusable or colliding names
+  - `pascalCase(s)`, `applyTableCase(tsName, 'preserve' | 'pascal')`
+  - Calling `resolveAffix()` with no options reproduces the original naming exactly, so the
+    generators and the oRPC router can never interpret one config two ways.

package/dist/index.cjs

@@ -100171,13 +100171,197 @@ ${codeblock}`, options8);
 // src/index.ts
 var index_exports2 = {};
 __export(index_exports2, {
+  AFFIX_PROBE_TABLE: () => AFFIX_PROBE_TABLE,
+  DEFAULT_IMPORT_EXTENSION: () => DEFAULT_IMPORT_EXTENSION,
+  DEFAULT_MODE_PREFIX: () => DEFAULT_MODE_PREFIX,
+  DEFAULT_SCHEMA_SUFFIX: () => DEFAULT_SCHEMA_SUFFIX,
+  DEFAULT_TYPE_SUFFIX: () => DEFAULT_TYPE_SUFFIX,
+  IMPORT_EXTENSIONS: () => IMPORT_EXTENSIONS,
+  NAME_MODES: () => NAME_MODES,
+  applyTableCase: () => applyTableCase,
   formatCode: () => formatCode,
+  importSpecifier: () => importSpecifier,
   insertColumns: () => insertColumns,
   isGeneratedColumn: () => isGeneratedColumn,
+  moduleFileName: () => moduleFileName,
+  moduleSpecifier: () => moduleSpecifier,
+  pascalCase: () => pascalCase,
+  resolveAffix: () => resolveAffix,
+  resolveConfiguredImport: () => resolveConfiguredImport,
+  schemaName: () => schemaName,
   selectColumns: () => selectColumns,
-  updateColumns: () => updateColumns
+  typeName: () => typeName,
+  updateColumns: () => updateColumns,
+  validateAffix: () => validateAffix
 });
 module.exports = __toCommonJS(index_exports2);
+
+// src/files.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var IMPORT_EXTENSIONS = ["js", "none", "ts"];
+var DEFAULT_IMPORT_EXTENSION = "js";
+var TS_EXTENSIONS = [
+  { ext: ".mts", js: ".mjs", none: ".mjs" },
+  { ext: ".cts", js: ".cjs", none: ".cjs" },
+  { ext: ".tsx", js: ".js", none: "" },
+  { ext: ".ts", js: ".js", none: "" }
+];
+function moduleFileName(tsName, fileSuffix) {
+  return `${tsName}${fileSuffix}`;
+}
+function importSpecifier(relativePath, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  for (const { ext, js: js8, none } of TS_EXTENSIONS) {
+    if (!relativePath.endsWith(ext)) continue;
+    const stem = relativePath.slice(0, -ext.length);
+    if (importExtension === "ts") return relativePath;
+    return `${stem}${importExtension === "none" ? none : js8}`;
+  }
+  return relativePath;
+}
+function moduleSpecifier(tsName, fileSuffix, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  return importSpecifier(`./${moduleFileName(tsName, fileSuffix)}`, importExtension);
+}
+function resolveConfiguredImport(configured, outDirAbs, cwd, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  if (isPackageSpecifier(configured)) return configured;
+  const targetAbs = import_node_path.default.isAbsolute(configured) ? configured : import_node_path.default.resolve(configured.startsWith(".") ? outDirAbs : cwd, configured);
+  const withIndex = pointsAtDirectory(targetAbs) ? `${configured}/index` : configured;
+  if (configured.startsWith(".")) {
+    return importSpecifier(withTsExtension(withIndex), importExtension);
+  }
+  const resolved = pointsAtDirectory(targetAbs) ? import_node_path.default.join(targetAbs, "index") : targetAbs;
+  const rel = import_node_path.default.relative(outDirAbs, resolved).split(import_node_path.default.sep).join("/");
+  const prefixed = !rel ? "." : rel.startsWith(".") ? rel : `./${rel}`;
+  return importSpecifier(withTsExtension(prefixed), importExtension);
+}
+function isPackageSpecifier(p5) {
+  if (p5.startsWith(".") || import_node_path.default.isAbsolute(p5)) return false;
+  if (p5.startsWith("@") || p5.includes(":")) return true;
+  return !p5.includes("/");
+}
+function pointsAtDirectory(absPath) {
+  try {
+    return import_node_fs.default.statSync(absPath).isDirectory();
+  } catch {
+    for (const ext of [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"]) {
+      if (import_node_fs.default.existsSync(`${absPath}${ext}`)) return false;
+    }
+    return !/\.[a-z]+$/i.test(import_node_path.default.basename(absPath));
+  }
+}
+function withTsExtension(p5) {
+  if (/\.(ts|tsx|mts|cts)$/.test(p5)) return p5;
+  if (/\.(js|mjs|cjs)$/.test(p5)) return p5.replace(/\.(js|mjs|cjs)$/, ".ts");
+  return `${p5}.ts`;
+}
+
+// src/naming.ts
+var NAME_MODES = ["insert", "update", "select"];
+var DEFAULT_MODE_PREFIX = {
+  insert: "Insert",
+  update: "Update",
+  select: "Select"
+};
+var DEFAULT_TYPE_SUFFIX = {
+  insert: "Input",
+  update: "Input",
+  select: "Output"
+};
+var DEFAULT_SCHEMA_SUFFIX = "Schema";
+var AFFIX_PROBE_TABLE = "users";
+function spread(value, fallback) {
+  if (value === void 0) return { ...fallback };
+  if (typeof value === "string") return { insert: value, update: value, select: value };
+  return {
+    insert: value.insert ?? fallback.insert,
+    update: value.update ?? fallback.update,
+    select: value.select ?? fallback.select
+  };
+}
+function pascalCase(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean).map((p5) => p5.charAt(0).toUpperCase() + p5.slice(1)).join("");
+}
+function applyTableCase(tsName, tableCase) {
+  return tableCase === "pascal" ? pascalCase(tsName) : tsName;
+}
+function resolveAffix(opts) {
+  const affix = opts?.affix;
+  const legacy = opts?.schemaSuffix ?? DEFAULT_SCHEMA_SUFFIX;
+  const legacyMap = {
+    insert: legacy,
+    update: legacy,
+    select: legacy
+  };
+  return {
+    tableCase: affix?.tableCase ?? "preserve",
+    schema: {
+      prefix: spread(affix?.schema?.prefix, DEFAULT_MODE_PREFIX),
+      suffix: spread(affix?.schema?.suffix, legacyMap)
+    },
+    type: {
+      prefix: spread(affix?.type?.prefix, DEFAULT_MODE_PREFIX),
+      suffix: spread(affix?.type?.suffix, DEFAULT_TYPE_SUFFIX)
+    }
+  };
+}
+function schemaName(mode, tsName, affix) {
+  return affix.schema.prefix[mode] + applyTableCase(tsName, affix.tableCase) + affix.schema.suffix[mode];
+}
+function typeName(mode, tsName, affix) {
+  return affix.type.prefix[mode] + applyTableCase(tsName, affix.tableCase) + affix.type.suffix[mode];
+}
+var PREFIX_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var SUFFIX_RE = /^[A-Za-z0-9_$]+$/;
+function validateAffix(affix, schemaSuffix) {
+  const issues = [];
+  if (!affix) return issues;
+  const checkOne = (value, path14, kind) => {
+    if (value === "") return;
+    const ok = kind === "prefix" ? PREFIX_RE.test(value) : SUFFIX_RE.test(value);
+    if (ok) return;
+    issues.push({
+      path: path14,
+      message: `${JSON.stringify(value)} cannot appear in a TypeScript identifier. Use only letters, digits, "_" and "$"` + (kind === "prefix" ? ", and do not start with a digit." : ".")
+    });
+  };
+  const checkValue = (value, base, kind) => {
+    if (value === void 0) return;
+    if (typeof value === "string") {
+      checkOne(value, base, kind);
+      return;
+    }
+    for (const mode of NAME_MODES) {
+      const v7 = value[mode];
+      if (v7 !== void 0) checkOne(v7, [...base, mode], kind);
+    }
+  };
+  checkValue(affix.schema?.prefix, ["schema", "prefix"], "prefix");
+  checkValue(affix.schema?.suffix, ["schema", "suffix"], "suffix");
+  checkValue(affix.type?.prefix, ["type", "prefix"], "prefix");
+  checkValue(affix.type?.suffix, ["type", "suffix"], "suffix");
+  if (issues.length) return issues;
+  const resolved = resolveAffix({ affix, schemaSuffix });
+  const collisions = (space, build) => {
+    const seen = /* @__PURE__ */ new Map();
+    for (const mode of NAME_MODES) {
+      const name = build(mode);
+      const first = seen.get(name);
+      if (first) {
+        issues.push({
+          path: [space],
+          message: `The ${space} names for "${first}" and "${mode}" collide: both resolve to "${name}". All three are emitted into the same file, so at least one prefix or suffix has to differ.`
+        });
+      } else {
+        seen.set(name, mode);
+      }
+    }
+  };
+  collisions("schema", (mode) => schemaName(mode, AFFIX_PROBE_TABLE, resolved));
+  collisions("type", (mode) => typeName(mode, AFFIX_PROBE_TABLE, resolved));
+  return issues;
+}
+
+// src/index.ts
 function isGeneratedColumn(c5, primaryKeyColumns) {
   return c5.isGenerated || primaryKeyColumns.includes(c5.name);
 }
@@ -100219,9 +100403,26 @@ async function formatCode(code, filePath, fmt) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AFFIX_PROBE_TABLE,
+  DEFAULT_IMPORT_EXTENSION,
+  DEFAULT_MODE_PREFIX,
+  DEFAULT_SCHEMA_SUFFIX,
+  DEFAULT_TYPE_SUFFIX,
+  IMPORT_EXTENSIONS,
+  NAME_MODES,
+  applyTableCase,
   formatCode,
+  importSpecifier,
   insertColumns,
   isGeneratedColumn,
+  moduleFileName,
+  moduleSpecifier,
+  pascalCase,
+  resolveAffix,
+  resolveConfiguredImport,
+  schemaName,
   selectColumns,
-  updateColumns
+  typeName,
+  updateColumns,
+  validateAffix
 });

package/dist/index.d.cts

@@ -1,5 +1,178 @@
 import { Column, Analysis } from '@drzl/analyzer';
 
+/**
+ * One place that decides what a generated module is called, on disk and in an import.
+ *
+ * The three validation generators used to name the file from `fileSuffix` but hardcode the
+ * default suffix in the barrel, so any custom `fileSuffix` produced `export * from
+ * './users.zod'` next to a file called `users.schema.ts` and the consumer's build failed on
+ * an unresolved import. Both halves are derived here from the same value now.
+ */
+/**
+ * How a relative import of a generated file spells its extension.
+ *
+ * Generated files land in the consumer's own source tree, so the consumer's
+ * `moduleResolution` decides which forms resolve. Measured against tsc 5.9.2 and 7.0.2, for
+ * a specifier pointing at a sibling `.ts` file:
+ *
+ * | form            | bundler | node10 | node16 / nodenext (CJS) | node16 / nodenext (ESM) |
+ * | --------------- | ------- | ------ | ----------------------- | ----------------------- |
+ * | `'js'`          | yes     | yes    | yes                     | yes                     |
+ * | `'none'`        | yes     | yes    | yes                     | **no**                  |
+ * | `'ts'`          | flag    | flag   | flag                    | flag                    |
+ *
+ * `'js'` is the default because it is the only form that needs no compiler flag and still
+ * resolves in every cell. `'none'` is what drzl emitted before 2.0 and is what a pipeline
+ * that cannot map `.js` back to `.ts` wants (webpack without `resolve.extensionAlias`,
+ * ts-jest without a `moduleNameMapper`). `'ts'` needs `allowImportingTsExtensions`, and is
+ * the only form Node's own type stripping accepts, so it suits a project that runs the
+ * generated `.ts` unbuilt.
+ */
+type ImportExtension = (typeof IMPORT_EXTENSIONS)[number];
+/**
+ * Every value `ImportExtension` accepts, in the order documentation lists them. The type is
+ * derived from this tuple rather than declared alongside it, so a config schema built from
+ * it accepts exactly what the type allows and the two cannot drift.
+ */
+declare const IMPORT_EXTENSIONS: readonly ["js", "none", "ts"];
+/** What `importExtension` means when nothing sets it. */
+declare const DEFAULT_IMPORT_EXTENSION: ImportExtension;
+/** Name of the file a table is written to, e.g. `users.zod.ts`. */
+declare function moduleFileName(tsName: string, fileSuffix: string): string;
+/**
+ * Rewrite the extension of a relative path naming a generated file into the form an import
+ * specifier has to spell, e.g. `./users.zod.ts` -> `./users.zod.js`.
+ *
+ * A path that ends in no TypeScript extension is left whole: such a file cannot be imported
+ * at all, and naming a neighbour that does not exist would only hide that.
+ */
+declare function importSpecifier(relativePath: string, importExtension?: ImportExtension): string;
+/**
+ * Relative specifier a sibling module needs to import a table's file, e.g.
+ * `./users.zod.js`.
+ */
+declare function moduleSpecifier(tsName: string, fileSuffix: string, importExtension?: ImportExtension): string;
+/**
+ * Turn a configured module path into a specifier the generated file can actually import.
+ *
+ * Options like `validation.importPath`, `dbImportPath` and `schemaImportPath` get written as
+ * project-relative paths, `src/validators/zod`, because that is how the rest of the config
+ * names directories. Emitted verbatim that is a *bare* specifier: Node and tsc look for a
+ * package of that name in node_modules and never consider the local file. The config in the
+ * getting-started guide produced three such imports, none of which resolved.
+ *
+ * Two questions have to be answered, and neither can be guessed from the string alone.
+ *
+ * **Package or path?** `zod` and `@acme/schemas` are package names and pass through untouched.
+ * A path containing a separator, or starting with `.`, is a path.
+ *
+ * **File or directory?** `src/db/connection` is usually a file and `src/validators/zod` a
+ * directory holding a barrel, and they look identical. So the filesystem is asked. Where the
+ * target does not exist yet, which happens when this generator runs before the one that writes
+ * it, an extensionless path is taken to be a directory, since these options name directories by
+ * convention and the one path that can be missing is a generated barrel.
+ *
+ * A path already relative keeps its own spelling and only has its extension corrected, so
+ * anyone who followed the older guidance and wrote `../validators/zod/index.js` is unaffected.
+ *
+ * @param configured  what the user put in the config
+ * @param outDirAbs   absolute directory the importing file is written to
+ * @param cwd         project root a non-relative path is resolved against
+ */
+declare function resolveConfiguredImport(configured: string, outDirAbs: string, cwd: string, importExtension?: ImportExtension): string;
+
+/**
+ * One place that decides what a generated identifier is called.
+ *
+ * Every generator used to build these names by hand with template literals, which is why
+ * the oRPC router and the zod/valibot/arktype generators could silently disagree about the
+ * same name. They all call through here now, so a single resolved value describes both
+ * sides of the import.
+ *
+ * Defaults reproduce the pre-affix output byte for byte:
+ *   schema: Insert|Update|Select + <tsName> + (schemaSuffix ?? 'Schema')
+ *   type:   Insert|Update|Select + <tsName> + Input|Input|Output
+ */
+type NameMode = 'insert' | 'update' | 'select';
+/** How the Drizzle export name is cased before it goes into an identifier. */
+type TableCase = 'preserve' | 'pascal';
+/** One affix for all three modes, or a per-mode override map. */
+type AffixValue = string | Partial<Record<NameMode, string>>;
+interface AffixOptions {
+    /**
+     * `preserve` (default) interpolates the Drizzle export name verbatim, which is what every
+     * released version does: `export const users` yields `InsertusersSchema`. `pascal` upper-camels
+     * it first, yielding `InsertUsersSchema`. Identifiers only; file names are never re-cased.
+     */
+    tableCase?: TableCase;
+    /** Affixes for the exported schema constants. */
+    schema?: {
+        prefix?: AffixValue;
+        suffix?: AffixValue;
+    };
+    /** Affixes for the exported type aliases. Independent of `schema`. */
+    type?: {
+        prefix?: AffixValue;
+        suffix?: AffixValue;
+    };
+}
+interface ResolvedAffix {
+    tableCase: TableCase;
+    schema: {
+        prefix: Record<NameMode, string>;
+        suffix: Record<NameMode, string>;
+    };
+    type: {
+        prefix: Record<NameMode, string>;
+        suffix: Record<NameMode, string>;
+    };
+}
+interface AffixIssue {
+    /** Path relative to the affix object, e.g. `['schema', 'suffix']`. */
+    path: (string | number)[];
+    message: string;
+}
+declare const NAME_MODES: readonly NameMode[];
+declare const DEFAULT_MODE_PREFIX: Readonly<Record<NameMode, string>>;
+declare const DEFAULT_TYPE_SUFFIX: Readonly<Record<NameMode, string>>;
+declare const DEFAULT_SCHEMA_SUFFIX = "Schema";
+/** Table name used when a config is checked for invalid or colliding names. */
+declare const AFFIX_PROBE_TABLE = "users";
+/**
+ * Real PascalCase, unlike the `cap()` helpers scattered around the repo which only upcase
+ * character zero. Splits on `_`, `-`, whitespace and camel boundaries, and leaves the rest of
+ * each part alone so acronyms survive (`userID` -> `UserID`, not `Userid`).
+ */
+declare function pascalCase(s: string): string;
+declare function applyTableCase(tsName: string, tableCase: TableCase): string;
+/**
+ * Fold an `affix` block and the legacy flat `schemaSuffix` into one fully-populated value.
+ * `affix.schema.suffix` wins over `schemaSuffix`; `schemaSuffix` wins over the built-in
+ * `'Schema'`. Calling with no arguments returns exactly today's naming.
+ */
+declare function resolveAffix(opts?: {
+    affix?: AffixOptions;
+    schemaSuffix?: string;
+}): ResolvedAffix;
+/** Name of the exported schema constant, e.g. `InsertusersSchema`. */
+declare function schemaName(mode: NameMode, tsName: string, affix: ResolvedAffix): string;
+/** Name of the exported type alias, e.g. `InsertusersInput`. */
+declare function typeName(mode: NameMode, tsName: string, affix: ResolvedAffix): string;
+/**
+ * Reject affixes that cannot produce a compilable file, before anything is written:
+ *  - characters that are not legal in a TypeScript identifier
+ *  - two names in the same declaration space resolving to the same string
+ *
+ * A schema name equal to a type name is allowed on purpose: `export const X` and
+ * `export type X` occupy different declaration spaces, and the generators already emit
+ * `type ... = z.input<typeof ...>` pairs.
+ *
+ * Only what the caller actually wrote in `affix` is checked. The legacy flat `schemaSuffix`
+ * is not character-checked, because it never was, and rejecting it now would break configs
+ * that parse today.
+ */
+declare function validateAffix(affix?: AffixOptions, schemaSuffix?: string): AffixIssue[];
+
 interface Table {
     name: string;
     tsName: string;
@@ -17,8 +190,26 @@ interface FormatOptions {
 interface ValidationGenerateOptions {
     outDir: string;
     format?: FormatOptions;
+    /**
+     * What every generated file is called after the Drizzle export name, e.g. `.zod.ts`
+     * yields `users.zod.ts`. The barrel derives its import specifiers from this same value,
+     * so a custom suffix keeps resolving.
+     */
     fileSuffix?: string;
+    /**
+     * How the barrel spells the extension of the files it re-exports. Defaults to `'js'`,
+     * so `users.zod.ts` is imported as `./users.zod.js`, the only form that resolves under
+     * every `moduleResolution` without a compiler flag. Use `'none'` for the extensionless
+     * specifiers drzl emitted before 2.0.
+     */
+    importExtension?: ImportExtension;
     schemaSuffix?: string;
+    /**
+     * Prefixes, suffixes and table casing for the generated identifiers. Omit it and the
+     * output is identical to every previous version; `schemaSuffix` stays the fallback for
+     * `affix.schema.suffix`.
+     */
+    affix?: AffixOptions;
     coerceDates?: 'input' | 'all' | 'none';
     emit?: {
         select?: boolean;
@@ -38,4 +229,4 @@ declare function updateColumns(table: Table): Column[];
 declare function selectColumns(table: Table): Column[];
 declare function formatCode(code: string, filePath: string, fmt?: FormatOptions): Promise<any>;
 
-export { type FormatOptions, type Table, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, formatCode, insertColumns, isGeneratedColumn, selectColumns, updateColumns };
+export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, DEFAULT_IMPORT_EXTENSION, DEFAULT_MODE_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_TYPE_SUFFIX, type FormatOptions, IMPORT_EXTENSIONS, type ImportExtension, NAME_MODES, type NameMode, type ResolvedAffix, type Table, type TableCase, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, applyTableCase, formatCode, importSpecifier, insertColumns, isGeneratedColumn, moduleFileName, moduleSpecifier, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };

package/dist/index.d.ts

@@ -1,5 +1,178 @@
 import { Column, Analysis } from '@drzl/analyzer';
 
+/**
+ * One place that decides what a generated module is called, on disk and in an import.
+ *
+ * The three validation generators used to name the file from `fileSuffix` but hardcode the
+ * default suffix in the barrel, so any custom `fileSuffix` produced `export * from
+ * './users.zod'` next to a file called `users.schema.ts` and the consumer's build failed on
+ * an unresolved import. Both halves are derived here from the same value now.
+ */
+/**
+ * How a relative import of a generated file spells its extension.
+ *
+ * Generated files land in the consumer's own source tree, so the consumer's
+ * `moduleResolution` decides which forms resolve. Measured against tsc 5.9.2 and 7.0.2, for
+ * a specifier pointing at a sibling `.ts` file:
+ *
+ * | form            | bundler | node10 | node16 / nodenext (CJS) | node16 / nodenext (ESM) |
+ * | --------------- | ------- | ------ | ----------------------- | ----------------------- |
+ * | `'js'`          | yes     | yes    | yes                     | yes                     |
+ * | `'none'`        | yes     | yes    | yes                     | **no**                  |
+ * | `'ts'`          | flag    | flag   | flag                    | flag                    |
+ *
+ * `'js'` is the default because it is the only form that needs no compiler flag and still
+ * resolves in every cell. `'none'` is what drzl emitted before 2.0 and is what a pipeline
+ * that cannot map `.js` back to `.ts` wants (webpack without `resolve.extensionAlias`,
+ * ts-jest without a `moduleNameMapper`). `'ts'` needs `allowImportingTsExtensions`, and is
+ * the only form Node's own type stripping accepts, so it suits a project that runs the
+ * generated `.ts` unbuilt.
+ */
+type ImportExtension = (typeof IMPORT_EXTENSIONS)[number];
+/**
+ * Every value `ImportExtension` accepts, in the order documentation lists them. The type is
+ * derived from this tuple rather than declared alongside it, so a config schema built from
+ * it accepts exactly what the type allows and the two cannot drift.
+ */
+declare const IMPORT_EXTENSIONS: readonly ["js", "none", "ts"];
+/** What `importExtension` means when nothing sets it. */
+declare const DEFAULT_IMPORT_EXTENSION: ImportExtension;
+/** Name of the file a table is written to, e.g. `users.zod.ts`. */
+declare function moduleFileName(tsName: string, fileSuffix: string): string;
+/**
+ * Rewrite the extension of a relative path naming a generated file into the form an import
+ * specifier has to spell, e.g. `./users.zod.ts` -> `./users.zod.js`.
+ *
+ * A path that ends in no TypeScript extension is left whole: such a file cannot be imported
+ * at all, and naming a neighbour that does not exist would only hide that.
+ */
+declare function importSpecifier(relativePath: string, importExtension?: ImportExtension): string;
+/**
+ * Relative specifier a sibling module needs to import a table's file, e.g.
+ * `./users.zod.js`.
+ */
+declare function moduleSpecifier(tsName: string, fileSuffix: string, importExtension?: ImportExtension): string;
+/**
+ * Turn a configured module path into a specifier the generated file can actually import.
+ *
+ * Options like `validation.importPath`, `dbImportPath` and `schemaImportPath` get written as
+ * project-relative paths, `src/validators/zod`, because that is how the rest of the config
+ * names directories. Emitted verbatim that is a *bare* specifier: Node and tsc look for a
+ * package of that name in node_modules and never consider the local file. The config in the
+ * getting-started guide produced three such imports, none of which resolved.
+ *
+ * Two questions have to be answered, and neither can be guessed from the string alone.
+ *
+ * **Package or path?** `zod` and `@acme/schemas` are package names and pass through untouched.
+ * A path containing a separator, or starting with `.`, is a path.
+ *
+ * **File or directory?** `src/db/connection` is usually a file and `src/validators/zod` a
+ * directory holding a barrel, and they look identical. So the filesystem is asked. Where the
+ * target does not exist yet, which happens when this generator runs before the one that writes
+ * it, an extensionless path is taken to be a directory, since these options name directories by
+ * convention and the one path that can be missing is a generated barrel.
+ *
+ * A path already relative keeps its own spelling and only has its extension corrected, so
+ * anyone who followed the older guidance and wrote `../validators/zod/index.js` is unaffected.
+ *
+ * @param configured  what the user put in the config
+ * @param outDirAbs   absolute directory the importing file is written to
+ * @param cwd         project root a non-relative path is resolved against
+ */
+declare function resolveConfiguredImport(configured: string, outDirAbs: string, cwd: string, importExtension?: ImportExtension): string;
+
+/**
+ * One place that decides what a generated identifier is called.
+ *
+ * Every generator used to build these names by hand with template literals, which is why
+ * the oRPC router and the zod/valibot/arktype generators could silently disagree about the
+ * same name. They all call through here now, so a single resolved value describes both
+ * sides of the import.
+ *
+ * Defaults reproduce the pre-affix output byte for byte:
+ *   schema: Insert|Update|Select + <tsName> + (schemaSuffix ?? 'Schema')
+ *   type:   Insert|Update|Select + <tsName> + Input|Input|Output
+ */
+type NameMode = 'insert' | 'update' | 'select';
+/** How the Drizzle export name is cased before it goes into an identifier. */
+type TableCase = 'preserve' | 'pascal';
+/** One affix for all three modes, or a per-mode override map. */
+type AffixValue = string | Partial<Record<NameMode, string>>;
+interface AffixOptions {
+    /**
+     * `preserve` (default) interpolates the Drizzle export name verbatim, which is what every
+     * released version does: `export const users` yields `InsertusersSchema`. `pascal` upper-camels
+     * it first, yielding `InsertUsersSchema`. Identifiers only; file names are never re-cased.
+     */
+    tableCase?: TableCase;
+    /** Affixes for the exported schema constants. */
+    schema?: {
+        prefix?: AffixValue;
+        suffix?: AffixValue;
+    };
+    /** Affixes for the exported type aliases. Independent of `schema`. */
+    type?: {
+        prefix?: AffixValue;
+        suffix?: AffixValue;
+    };
+}
+interface ResolvedAffix {
+    tableCase: TableCase;
+    schema: {
+        prefix: Record<NameMode, string>;
+        suffix: Record<NameMode, string>;
+    };
+    type: {
+        prefix: Record<NameMode, string>;
+        suffix: Record<NameMode, string>;
+    };
+}
+interface AffixIssue {
+    /** Path relative to the affix object, e.g. `['schema', 'suffix']`. */
+    path: (string | number)[];
+    message: string;
+}
+declare const NAME_MODES: readonly NameMode[];
+declare const DEFAULT_MODE_PREFIX: Readonly<Record<NameMode, string>>;
+declare const DEFAULT_TYPE_SUFFIX: Readonly<Record<NameMode, string>>;
+declare const DEFAULT_SCHEMA_SUFFIX = "Schema";
+/** Table name used when a config is checked for invalid or colliding names. */
+declare const AFFIX_PROBE_TABLE = "users";
+/**
+ * Real PascalCase, unlike the `cap()` helpers scattered around the repo which only upcase
+ * character zero. Splits on `_`, `-`, whitespace and camel boundaries, and leaves the rest of
+ * each part alone so acronyms survive (`userID` -> `UserID`, not `Userid`).
+ */
+declare function pascalCase(s: string): string;
+declare function applyTableCase(tsName: string, tableCase: TableCase): string;
+/**
+ * Fold an `affix` block and the legacy flat `schemaSuffix` into one fully-populated value.
+ * `affix.schema.suffix` wins over `schemaSuffix`; `schemaSuffix` wins over the built-in
+ * `'Schema'`. Calling with no arguments returns exactly today's naming.
+ */
+declare function resolveAffix(opts?: {
+    affix?: AffixOptions;
+    schemaSuffix?: string;
+}): ResolvedAffix;
+/** Name of the exported schema constant, e.g. `InsertusersSchema`. */
+declare function schemaName(mode: NameMode, tsName: string, affix: ResolvedAffix): string;
+/** Name of the exported type alias, e.g. `InsertusersInput`. */
+declare function typeName(mode: NameMode, tsName: string, affix: ResolvedAffix): string;
+/**
+ * Reject affixes that cannot produce a compilable file, before anything is written:
+ *  - characters that are not legal in a TypeScript identifier
+ *  - two names in the same declaration space resolving to the same string
+ *
+ * A schema name equal to a type name is allowed on purpose: `export const X` and
+ * `export type X` occupy different declaration spaces, and the generators already emit
+ * `type ... = z.input<typeof ...>` pairs.
+ *
+ * Only what the caller actually wrote in `affix` is checked. The legacy flat `schemaSuffix`
+ * is not character-checked, because it never was, and rejecting it now would break configs
+ * that parse today.
+ */
+declare function validateAffix(affix?: AffixOptions, schemaSuffix?: string): AffixIssue[];
+
 interface Table {
     name: string;
     tsName: string;
@@ -17,8 +190,26 @@ interface FormatOptions {
 interface ValidationGenerateOptions {
     outDir: string;
     format?: FormatOptions;
+    /**
+     * What every generated file is called after the Drizzle export name, e.g. `.zod.ts`
+     * yields `users.zod.ts`. The barrel derives its import specifiers from this same value,
+     * so a custom suffix keeps resolving.
+     */
     fileSuffix?: string;
+    /**
+     * How the barrel spells the extension of the files it re-exports. Defaults to `'js'`,
+     * so `users.zod.ts` is imported as `./users.zod.js`, the only form that resolves under
+     * every `moduleResolution` without a compiler flag. Use `'none'` for the extensionless
+     * specifiers drzl emitted before 2.0.
+     */
+    importExtension?: ImportExtension;
     schemaSuffix?: string;
+    /**
+     * Prefixes, suffixes and table casing for the generated identifiers. Omit it and the
+     * output is identical to every previous version; `schemaSuffix` stays the fallback for
+     * `affix.schema.suffix`.
+     */
+    affix?: AffixOptions;
     coerceDates?: 'input' | 'all' | 'none';
     emit?: {
         select?: boolean;
@@ -38,4 +229,4 @@ declare function updateColumns(table: Table): Column[];
 declare function selectColumns(table: Table): Column[];
 declare function formatCode(code: string, filePath: string, fmt?: FormatOptions): Promise<any>;
 
-export { type FormatOptions, type Table, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, formatCode, insertColumns, isGeneratedColumn, selectColumns, updateColumns };
+export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, DEFAULT_IMPORT_EXTENSION, DEFAULT_MODE_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_TYPE_SUFFIX, type FormatOptions, IMPORT_EXTENSIONS, type ImportExtension, NAME_MODES, type NameMode, type ResolvedAffix, type Table, type TableCase, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, applyTableCase, formatCode, importSpecifier, insertColumns, isGeneratedColumn, moduleFileName, moduleSpecifier, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };

package/dist/index.js

@@ -1,5 +1,170 @@
 import "./chunk-MKBO26DX.js";
 
+// src/files.ts
+import nodeFs from "fs";
+import nodePath from "path";
+var IMPORT_EXTENSIONS = ["js", "none", "ts"];
+var DEFAULT_IMPORT_EXTENSION = "js";
+var TS_EXTENSIONS = [
+  { ext: ".mts", js: ".mjs", none: ".mjs" },
+  { ext: ".cts", js: ".cjs", none: ".cjs" },
+  { ext: ".tsx", js: ".js", none: "" },
+  { ext: ".ts", js: ".js", none: "" }
+];
+function moduleFileName(tsName, fileSuffix) {
+  return `${tsName}${fileSuffix}`;
+}
+function importSpecifier(relativePath, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  for (const { ext, js, none } of TS_EXTENSIONS) {
+    if (!relativePath.endsWith(ext)) continue;
+    const stem = relativePath.slice(0, -ext.length);
+    if (importExtension === "ts") return relativePath;
+    return `${stem}${importExtension === "none" ? none : js}`;
+  }
+  return relativePath;
+}
+function moduleSpecifier(tsName, fileSuffix, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  return importSpecifier(`./${moduleFileName(tsName, fileSuffix)}`, importExtension);
+}
+function resolveConfiguredImport(configured, outDirAbs, cwd, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  if (isPackageSpecifier(configured)) return configured;
+  const targetAbs = nodePath.isAbsolute(configured) ? configured : nodePath.resolve(configured.startsWith(".") ? outDirAbs : cwd, configured);
+  const withIndex = pointsAtDirectory(targetAbs) ? `${configured}/index` : configured;
+  if (configured.startsWith(".")) {
+    return importSpecifier(withTsExtension(withIndex), importExtension);
+  }
+  const resolved = pointsAtDirectory(targetAbs) ? nodePath.join(targetAbs, "index") : targetAbs;
+  const rel = nodePath.relative(outDirAbs, resolved).split(nodePath.sep).join("/");
+  const prefixed = !rel ? "." : rel.startsWith(".") ? rel : `./${rel}`;
+  return importSpecifier(withTsExtension(prefixed), importExtension);
+}
+function isPackageSpecifier(p) {
+  if (p.startsWith(".") || nodePath.isAbsolute(p)) return false;
+  if (p.startsWith("@") || p.includes(":")) return true;
+  return !p.includes("/");
+}
+function pointsAtDirectory(absPath) {
+  try {
+    return nodeFs.statSync(absPath).isDirectory();
+  } catch {
+    for (const ext of [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"]) {
+      if (nodeFs.existsSync(`${absPath}${ext}`)) return false;
+    }
+    return !/\.[a-z]+$/i.test(nodePath.basename(absPath));
+  }
+}
+function withTsExtension(p) {
+  if (/\.(ts|tsx|mts|cts)$/.test(p)) return p;
+  if (/\.(js|mjs|cjs)$/.test(p)) return p.replace(/\.(js|mjs|cjs)$/, ".ts");
+  return `${p}.ts`;
+}
+
+// src/naming.ts
+var NAME_MODES = ["insert", "update", "select"];
+var DEFAULT_MODE_PREFIX = {
+  insert: "Insert",
+  update: "Update",
+  select: "Select"
+};
+var DEFAULT_TYPE_SUFFIX = {
+  insert: "Input",
+  update: "Input",
+  select: "Output"
+};
+var DEFAULT_SCHEMA_SUFFIX = "Schema";
+var AFFIX_PROBE_TABLE = "users";
+function spread(value, fallback) {
+  if (value === void 0) return { ...fallback };
+  if (typeof value === "string") return { insert: value, update: value, select: value };
+  return {
+    insert: value.insert ?? fallback.insert,
+    update: value.update ?? fallback.update,
+    select: value.select ?? fallback.select
+  };
+}
+function pascalCase(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function applyTableCase(tsName, tableCase) {
+  return tableCase === "pascal" ? pascalCase(tsName) : tsName;
+}
+function resolveAffix(opts) {
+  const affix = opts?.affix;
+  const legacy = opts?.schemaSuffix ?? DEFAULT_SCHEMA_SUFFIX;
+  const legacyMap = {
+    insert: legacy,
+    update: legacy,
+    select: legacy
+  };
+  return {
+    tableCase: affix?.tableCase ?? "preserve",
+    schema: {
+      prefix: spread(affix?.schema?.prefix, DEFAULT_MODE_PREFIX),
+      suffix: spread(affix?.schema?.suffix, legacyMap)
+    },
+    type: {
+      prefix: spread(affix?.type?.prefix, DEFAULT_MODE_PREFIX),
+      suffix: spread(affix?.type?.suffix, DEFAULT_TYPE_SUFFIX)
+    }
+  };
+}
+function schemaName(mode, tsName, affix) {
+  return affix.schema.prefix[mode] + applyTableCase(tsName, affix.tableCase) + affix.schema.suffix[mode];
+}
+function typeName(mode, tsName, affix) {
+  return affix.type.prefix[mode] + applyTableCase(tsName, affix.tableCase) + affix.type.suffix[mode];
+}
+var PREFIX_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var SUFFIX_RE = /^[A-Za-z0-9_$]+$/;
+function validateAffix(affix, schemaSuffix) {
+  const issues = [];
+  if (!affix) return issues;
+  const checkOne = (value, path, kind) => {
+    if (value === "") return;
+    const ok = kind === "prefix" ? PREFIX_RE.test(value) : SUFFIX_RE.test(value);
+    if (ok) return;
+    issues.push({
+      path,
+      message: `${JSON.stringify(value)} cannot appear in a TypeScript identifier. Use only letters, digits, "_" and "$"` + (kind === "prefix" ? ", and do not start with a digit." : ".")
+    });
+  };
+  const checkValue = (value, base, kind) => {
+    if (value === void 0) return;
+    if (typeof value === "string") {
+      checkOne(value, base, kind);
+      return;
+    }
+    for (const mode of NAME_MODES) {
+      const v = value[mode];
+      if (v !== void 0) checkOne(v, [...base, mode], kind);
+    }
+  };
+  checkValue(affix.schema?.prefix, ["schema", "prefix"], "prefix");
+  checkValue(affix.schema?.suffix, ["schema", "suffix"], "suffix");
+  checkValue(affix.type?.prefix, ["type", "prefix"], "prefix");
+  checkValue(affix.type?.suffix, ["type", "suffix"], "suffix");
+  if (issues.length) return issues;
+  const resolved = resolveAffix({ affix, schemaSuffix });
+  const collisions = (space, build) => {
+    const seen = /* @__PURE__ */ new Map();
+    for (const mode of NAME_MODES) {
+      const name = build(mode);
+      const first = seen.get(name);
+      if (first) {
+        issues.push({
+          path: [space],
+          message: `The ${space} names for "${first}" and "${mode}" collide: both resolve to "${name}". All three are emitted into the same file, so at least one prefix or suffix has to differ.`
+        });
+      } else {
+        seen.set(name, mode);
+      }
+    }
+  };
+  collisions("schema", (mode) => schemaName(mode, AFFIX_PROBE_TABLE, resolved));
+  collisions("type", (mode) => typeName(mode, AFFIX_PROBE_TABLE, resolved));
+  return issues;
+}
+
 // src/index.ts
 function isGeneratedColumn(c, primaryKeyColumns) {
   return c.isGenerated || primaryKeyColumns.includes(c.name);
@@ -41,9 +206,26 @@ async function formatCode(code, filePath, fmt) {
   return code;
 }
 export {
+  AFFIX_PROBE_TABLE,
+  DEFAULT_IMPORT_EXTENSION,
+  DEFAULT_MODE_PREFIX,
+  DEFAULT_SCHEMA_SUFFIX,
+  DEFAULT_TYPE_SUFFIX,
+  IMPORT_EXTENSIONS,
+  NAME_MODES,
+  applyTableCase,
   formatCode,
+  importSpecifier,
   insertColumns,
   isGeneratedColumn,
+  moduleFileName,
+  moduleSpecifier,
+  pascalCase,
+  resolveAffix,
+  resolveConfiguredImport,
+  schemaName,
   selectColumns,
-  updateColumns
+  typeName,
+  updateColumns,
+  validateAffix
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drzl/validation-core",
-  "version": "1.1.0",
+  "version": "2.1.0",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -11,7 +11,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@drzl/analyzer": "^1.2.0"
+    "@drzl/analyzer": "^1.4.0"
   },
   "devDependencies": {
     "tsup": "^8.5.0",