hekireki 0.2.6 → 0.2.8

package/README.md

@@ -93,7 +93,7 @@ model Post {
 ## Zod
 
 ```ts
-import { z } from 'zod/v4'
+import * as z from 'zod'
 
 export const UserSchema = z.object({
   /**
@@ -191,9 +191,15 @@ erDiagram
 ```elixir
 defmodule DBSchema.User do
   use Ecto.Schema
-  @primary_key false
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+
+  @type t :: %__MODULE__{
+          id: Ecto.UUID.t(),
+          name: String.t()
+        }
+
   schema "user" do
-    field(:id, :binary_id, primary_key: true)
     field(:name, :string)
   end
 end
@@ -202,9 +208,17 @@ end
 ```elixir
 defmodule DBSchema.Post do
   use Ecto.Schema
-  @primary_key false
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+
+  @type t :: %__MODULE__{
+          id: Ecto.UUID.t(),
+          title: String.t(),
+          content: String.t(),
+          userId: String.t()
+        }
+
   schema "post" do
-    field(:id, :binary_id, primary_key: true)
     field(:title, :string)
     field(:content, :string)
     field(:userId, :string)
@@ -222,7 +236,7 @@ end
 | `file`       | `string`  | `index.ts`                          | File Name                                        |
 | `type`       | `boolean` | `false`                             | Generate TypeScript types                        |
 | `comment`    | `boolean` | `false`                             | Include schema documentation                     |
-| `zod`        | `string`  | `'v4'`                              | Zod import version (`'v4-mini'`, `'@hono/zod-openapi'`, or default `'v4'`) |
+| `zod`        | `string`  | `'v4'`                              | Zod import version (`'mini'`, `'@hono/zod-openapi'`, or default `'v4'`) |
 
 ### Valibot Generator Options
 

package/dist/generator/ecto/generator/ecto.js

@@ -20,6 +20,56 @@ function getPrimaryKeyConfig(field) {
         omitIdFieldInSchema: false,
     };
 }
+function getFieldDefaultOption(field) {
+    const def = field.default;
+    if (def === undefined || def === null)
+        return null;
+    if (typeof def === 'string')
+        return `default: "${def}"`;
+    if (typeof def === 'number' || typeof def === 'boolean')
+        return `default: ${def}`;
+    return null;
+}
+function ectoTypeToTypespec(type) {
+    switch (type) {
+        case 'string':
+            return 'String.t()';
+        case 'integer':
+            return 'integer()';
+        case 'float':
+            return 'float()';
+        case 'boolean':
+            return 'boolean()';
+        case 'binary_id':
+            return 'Ecto.UUID.t()';
+        case 'naive_datetime':
+            return 'NaiveDateTime.t()';
+        case 'utc_datetime':
+            return 'DateTime.t()';
+        default:
+            return 'term()';
+    }
+}
+function buildTimestampsLine(fields) {
+    const insertedAliases = ['inserted_at', 'created_at', 'createdAt'];
+    const updatedAliases = ['updated_at', 'modified_at', 'updatedAt', 'modifiedAt'];
+    const inserted = fields.find((f) => insertedAliases.includes(f.name));
+    const updated = fields.find((f) => updatedAliases.includes(f.name));
+    const exclude = new Set();
+    if (inserted)
+        exclude.add(inserted.name);
+    if (updated)
+        exclude.add(updated.name);
+    if (!(inserted || updated))
+        return { line: null, exclude };
+    if (inserted?.name === 'inserted_at' && updated?.name === 'updated_at') {
+        return { line: '    timestamps()', exclude };
+    }
+    return {
+        line: `    timestamps(inserted_at: :${inserted?.name ?? 'inserted_at'}, updated_at: :${updated?.name ?? 'updated_at'})`,
+        exclude,
+    };
+}
 export function ectoSchemas(models, app) {
     return models
         .map((model) => {
@@ -27,10 +77,12 @@ export function ectoSchemas(models, app) {
         if (!idField)
             return '';
         const pk = getPrimaryKeyConfig(idField);
-        const fields = model.fields.filter((f) => !(f.relationName || (f.isId && pk.omitIdFieldInSchema)));
+        const fields = model.fields.map((f) => ({ ...f }));
+        const { line: timestampsLine, exclude: timestampsExclude } = buildTimestampsLine(fields);
+        const schemaFieldsRaw = fields.filter((f) => !(f.relationName || (f.isId && pk.omitIdFieldInSchema) || timestampsExclude.has(f.name)));
         const typeSpecFields = [
             `id: ${pk.typeSpec}`,
-            ...fields.map((f) => `${f.name}: ${ectoTypeToTypespec(prismaTypeToEctoType(f.type))}`),
+            ...schemaFieldsRaw.map((f) => `${f.name}: ${ectoTypeToTypespec(prismaTypeToEctoType(f.type))}`),
         ];
         const typeSpecLines = [
             '  @type t :: %__MODULE__{',
@@ -40,9 +92,12 @@ export function ectoSchemas(models, app) {
             }),
             '        }',
         ];
-        const schemaFields = fields.map((f) => {
-            const type = prismaTypeToEctoType(f.type);
-            return `    field(:${f.name}, :${type})`;
+        const schemaFields = schemaFieldsRaw.map((f) => {
+            const type = f.isId ? 'binary_id' : prismaTypeToEctoType(f.type);
+            const primary = f.isId && !pk.omitIdFieldInSchema ? ', primary_key: true' : '';
+            const defaultOpt = getFieldDefaultOption(f);
+            const defaultClause = defaultOpt ? `, ${defaultOpt}` : '';
+            return `    field(:${f.name}, :${type}${primary}${defaultClause})`;
         });
         const lines = [
             `defmodule ${app}.${model.name} do`,
@@ -54,6 +109,7 @@ export function ectoSchemas(models, app) {
             '',
             `  schema "${snakeCase(model.name)}" do`,
             ...schemaFields,
+            ...(timestampsLine ? [timestampsLine] : []),
             '  end',
             'end',
         ];
@@ -62,26 +118,6 @@ export function ectoSchemas(models, app) {
         .filter(Boolean)
         .join('\n\n');
 }
-function ectoTypeToTypespec(type) {
-    switch (type) {
-        case 'string':
-            return 'String.t()';
-        case 'integer':
-            return 'integer()';
-        case 'float':
-            return 'float()';
-        case 'boolean':
-            return 'boolean()';
-        case 'binary_id':
-            return 'Ecto.UUID.t()';
-        case 'naive_datetime':
-            return 'NaiveDateTime.t()';
-        case 'utc_datetime':
-            return 'DateTime.t()';
-        default:
-            return 'term()';
-    }
-}
 export async function writeEctoSchemasToFiles(models, app, outDir) {
     await fsp.mkdir(outDir, { recursive: true });
     for (const model of models) {

package/dist/generator/mermaid-er/generator/er-content.d.ts

@@ -1,2 +1,8 @@
-import type { ERContent, Model } from '../types.js';
-export declare function erContent(models: readonly Model[]): ERContent;
+import type { DMMF } from '@prisma/generator-helper';
+/**
+ * Generate Mermaid ER diagram content from Prisma models.
+ *
+ * @param models - The list of Prisma DMMF models.
+ * @returns An array of Mermaid ER diagram lines.
+ */
+export declare function erContent(models: readonly DMMF.Model[]): readonly string[];

package/dist/generator/mermaid-er/generator/er-content.js

@@ -1,14 +1,16 @@
 import { modelInfo } from '../generator/index.js';
-import { extractRelations, removeDuplicateRelations } from '../validator/index.js';
-/**
- * generate ER content
- * @param { readonly Model[] } models - models
- * @returns { ERContent } - ER content
- */
+import { extractRelations } from '../helper/extract-relations.js';
+import { removeDuplicateRelations } from '../utils/index.js';
 // ER diagram header
 const ER_HEADER = ['```mermaid', 'erDiagram'];
 // ER diagram footer
 const ER_FOOTER = ['```'];
+/**
+ * Generate Mermaid ER diagram content from Prisma models.
+ *
+ * @param models - The list of Prisma DMMF models.
+ * @returns An array of Mermaid ER diagram lines.
+ */
 export function erContent(models) {
     // extract all relations
     const allRelations = models.flatMap(extractRelations);

package/dist/generator/mermaid-er/generator/index.d.ts

@@ -1,4 +1,4 @@
 export { erContent } from './er-content.js';
-export { modelInfo } from './model-info.js';
 export { modelFields } from './model-fields.js';
+export { modelInfo } from './model-info.js';
 export { relationLine } from './relation-line.js';

package/dist/generator/mermaid-er/generator/index.js

@@ -1,4 +1,4 @@
 export { erContent } from './er-content.js';
-export { modelInfo } from './model-info.js';
 export { modelFields } from './model-fields.js';
+export { modelInfo } from './model-info.js';
 export { relationLine } from './relation-line.js';

package/dist/generator/mermaid-er/generator/model-fields.d.ts

@@ -1,7 +1,8 @@
 import type { DMMF } from '@prisma/generator-helper';
 /**
- * generate model fields
- * @param { DMMF.Model } model
- * @returns { string[] }
+ * Generate Mermaid ER field lines from a Prisma model.
+ *
+ * @param model - A Prisma DMMF model definition.
+ * @returns An array of strings representing each field in Mermaid ER syntax, excluding relation fields and annotations.
  */
 export declare function modelFields(model: DMMF.Model): string[];

package/dist/generator/mermaid-er/generator/model-fields.js

@@ -1,9 +1,10 @@
 const ZOD_ANNOTATION = '@z.';
 const VALIBOT_ANNOTATION = '@v.';
 /**
- * generate model fields
- * @param { DMMF.Model } model
- * @returns { string[] }
+ * Generate Mermaid ER field lines from a Prisma model.
+ *
+ * @param model - A Prisma DMMF model definition.
+ * @returns An array of strings representing each field in Mermaid ER syntax, excluding relation fields and annotations.
  */
 export function modelFields(model) {
     return model.fields

package/dist/generator/mermaid-er/generator/model-info.d.ts

@@ -1,7 +1,8 @@
-import type { Model } from '../types.js';
+import type { DMMF } from '@prisma/generator-helper';
 /**
- * generate model info
- * @param model
- * @returns
+ * Generate Mermaid ER diagram model block from a Prisma model.
+ *
+ * @param model - A Prisma DMMF model definition.
+ * @returns An array of strings representing the model block in Mermaid ER syntax.
  */
-export declare function modelInfo(model: Model): readonly string[];
+export declare function modelInfo(model: DMMF.Model): readonly string[];

package/dist/generator/mermaid-er/generator/model-info.js

@@ -1,8 +1,9 @@
 import { modelFields } from './index.js';
 /**
- * generate model info
- * @param model
- * @returns
+ * Generate Mermaid ER diagram model block from a Prisma model.
+ *
+ * @param model - A Prisma DMMF model definition.
+ * @returns An array of strings representing the model block in Mermaid ER syntax.
  */
 export function modelInfo(model) {
     return [`    ${model.name} {`, ...modelFields(model), '    }'];

package/dist/generator/mermaid-er/generator/relation-line.d.ts

@@ -1,7 +1,13 @@
-import type { Relation } from '../types.js';
 /**
- * generate relation line
- * @param { Relation } relation
- * @returns { string } relation line
+ * Generate a Mermaid ER diagram relation line from a relation definition.
+ *
+ * @param relation - The relation definition including model and field names.
+ * @returns A string representing the relation line in Mermaid ER syntax.
  */
-export declare function relationLine(relation: Relation): string;
+export declare function relationLine(relation: {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+}): string;

package/dist/generator/mermaid-er/generator/relation-line.js

@@ -1,8 +1,9 @@
-import { buildRelationLine } from '../relationship/build-relation-line.js';
+import { buildRelationLine } from '../helper/build-relation-line.js';
 /**
- * generate relation line
- * @param { Relation } relation
- * @returns { string } relation line
+ * Generate a Mermaid ER diagram relation line from a relation definition.
+ *
+ * @param relation - The relation definition including model and field names.
+ * @returns A string representing the relation line in Mermaid ER syntax.
  */
 export function relationLine(relation) {
     const cardinality = buildRelationLine(relation.type);

package/dist/generator/mermaid-er/helper/build-relation-line.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generate a Mermaid ER diagram relation connector from a custom relationship string.
+ *
+ * @param input - A relationship string like `"one-to-many"` or `"zero-one-to-one-optional"`.
+ * @returns The Mermaid connector string (e.g., `"||--}|"` or `"|o..}o"`).
+ *
+ * @throws If the input format is invalid or contains unknown relationship types.
+ */
+export declare function buildRelationLine(input: string): string;

package/dist/generator/mermaid-er/{relationship → helper}/build-relation-line.js

@@ -1,10 +1,18 @@
-import { isRelationship } from '../validator/is-relationship.js';
+import { isRelationship } from '../utils/index.js';
 const RELATIONSHIPS = {
     'zero-one': '|o',
     one: '||',
     'zero-many': '}o',
     many: '}|',
 };
+/**
+ * Generate a Mermaid ER diagram relation connector from a custom relationship string.
+ *
+ * @param input - A relationship string like `"one-to-many"` or `"zero-one-to-one-optional"`.
+ * @returns The Mermaid connector string (e.g., `"||--}|"` or `"|o..}o"`).
+ *
+ * @throws If the input format is invalid or contains unknown relationship types.
+ */
 export function buildRelationLine(input) {
     const parts = input.split('-to-');
     if (parts.length !== 2) {

package/dist/generator/mermaid-er/helper/extract-relations.d.ts

@@ -0,0 +1,8 @@
+import type { DMMF } from '@prisma/generator-helper';
+/**
+ * Extract Mermaid ER diagram relation lines from a Prisma model.
+ *
+ * @param model - A Prisma DMMF model definition.
+ * @returns An array of Mermaid ER diagram relation lines based on `@relation` annotations.
+ */
+export declare function extractRelations(model: DMMF.Model): readonly string[];

package/dist/generator/mermaid-er/{validator → helper}/extract-relations.js

@@ -1,13 +1,13 @@
 import { relationLine } from '../generator/relation-line.js';
-import { parseRelation } from './index.js';
+import { parseRelation } from '../utils/index.js';
 /**
- * extract relations from model
- * @param { Model } model
- * @returns { readonly string[] }
+ * Extract Mermaid ER diagram relation lines from a Prisma model.
+ *
+ * @param model - A Prisma DMMF model definition.
+ * @returns An array of Mermaid ER diagram relation lines based on `@relation` annotations.
  */
 export function extractRelations(model) {
     const relations = [];
-    // @relation annotation
     if (model.documentation) {
         const annotationRelations = model.documentation
             .split('\n')

package/dist/generator/mermaid-er/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { erContent } from './generator/er-content.js';
 import fsp from 'node:fs/promises';
 import pkg from '@prisma/generator-helper';
+import { erContent } from './generator/er-content.js';
 const { generatorHandler } = pkg;
 export async function main(options) {
     const content = erContent(options.dmmf.datamodel.models);

package/dist/generator/mermaid-er/utils/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Remove duplicate relations and exclude any that are many-to-one.
+ *
+ * @param relations - An array of Mermaid ER diagram relation lines.
+ * @returns A filtered array excluding 'many-to-one' relations.
+ */
+export declare function excludeManyToOneRelations(relations: readonly string[]): readonly string[];
+/**
+ * Check if the given key is a valid relationship type.
+ *
+ * @param key - The key to check.
+ * @returns `true` if the key is one of the valid relationship types, otherwise `false`.
+ */
+export declare function isRelationship(key: string): key is 'zero-one' | 'one' | 'zero-many' | 'many';
+/**
+ * Parse a `@relation` annotation line into a structured relation object.
+ *
+ * @param line - A string representing a single `@relation` annotation.
+ * @returns An object containing relation details if the line is valid, otherwise `null`.
+ */
+export declare function parseRelation(line: string): {
+    fromModel: string;
+    fromField: string;
+    toModel: string;
+    toField: string;
+    type: string;
+} | null;
+/**
+ * Remove duplicate relation lines from an array of Mermaid ER diagram relations.
+ *
+ * @param relations - An array of relation lines (e.g., generated from `relationLine`).
+ * @returns A new array with duplicates removed, preserving insertion order.
+ */
+export declare function removeDuplicateRelations(relations: readonly string[]): readonly string[];

package/dist/generator/mermaid-er/utils/index.js

@@ -0,0 +1,48 @@
+/**
+ * Remove duplicate relations and exclude any that are many-to-one.
+ *
+ * @param relations - An array of Mermaid ER diagram relation lines.
+ * @returns A filtered array excluding 'many-to-one' relations.
+ */
+export function excludeManyToOneRelations(relations) {
+    return [...new Set(relations)].filter((r) => !r.includes('many-to-one'));
+}
+/**
+ * Check if the given key is a valid relationship type.
+ *
+ * @param key - The key to check.
+ * @returns `true` if the key is one of the valid relationship types, otherwise `false`.
+ */
+export function isRelationship(key) {
+    return ['zero-one', 'one', 'zero-many', 'many'].includes(key);
+}
+/**
+ * Parse a `@relation` annotation line into a structured relation object.
+ *
+ * @param line - A string representing a single `@relation` annotation.
+ * @returns An object containing relation details if the line is valid, otherwise `null`.
+ */
+export function parseRelation(line) {
+    const relationRegex = /^@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)$/;
+    const match = line.trim().match(relationRegex);
+    if (!match) {
+        return null;
+    }
+    const [, fromModel, fromField, toModel, toField, relationType] = match;
+    return {
+        fromModel,
+        fromField,
+        toModel,
+        toField,
+        type: relationType,
+    };
+}
+/**
+ * Remove duplicate relation lines from an array of Mermaid ER diagram relations.
+ *
+ * @param relations - An array of relation lines (e.g., generated from `relationLine`).
+ * @returns A new array with duplicates removed, preserving insertion order.
+ */
+export function removeDuplicateRelations(relations) {
+    return [...new Set(relations)];
+}

package/dist/generator/valibot/generator/index.d.ts

@@ -1,5 +1,3 @@
-export { inferInput } from './infer-input.js';
-export { properties } from './properties.js';
 export { schema } from './schema.js';
 export { schemas } from './schemas.js';
 export { valibot } from './valibot.js';

package/dist/generator/valibot/generator/index.js

@@ -1,5 +1,3 @@
-export { inferInput } from './infer-input.js';
-export { properties } from './properties.js';
 export { schema } from './schema.js';
 export { schemas } from './schemas.js';
 export { valibot } from './valibot.js';

package/dist/generator/valibot/generator/schemas.js

@@ -1,4 +1,4 @@
-import { properties } from './properties.js';
+import { properties } from '../utils/index.js';
 import { schema } from './schema.js';
 /**
  * generate valibot schemas

package/dist/generator/valibot/generator/valibot.d.ts

@@ -1,4 +1,4 @@
-import type { Model } from '../../mermaid-er/types.js';
+import type { DMMF } from '@prisma/generator-helper';
 /**
  * Generate Valibot schemas and types
  * @param models - The models to generate the Valibot schemas and types for
@@ -6,4 +6,4 @@ import type { Model } from '../../mermaid-er/types.js';
  * @param comment - Whether to include comments in the generated code
  * @returns The generated Valibot schemas and types
  */
-export declare function valibot(models: readonly Model[], type: boolean, comment: boolean): string;
+export declare function valibot(models: readonly Readonly<DMMF.Model>[], type: boolean, comment: boolean): string;

package/dist/generator/valibot/generator/valibot.js

@@ -1,10 +1,6 @@
-import { isValibot } from '../validator/is-valibot.js';
+import { groupByModel, isFields } from '../../../shared/utils/index.js';
+import { inferInput, isValibot, isValibotDocument } from '../utils/index.js';
 import { schemas } from './schemas.js';
-import { groupByModel } from '../../../shared/helper/group-by-model.js';
-import { isFields } from '../../../shared/validator/is-fields.js';
-import { inferInput } from './infer-input.js';
-import { isValibotDocument } from '../validator/is-valibot-document.js';
-const VALIBOT_IMPORT = `import * as v from 'valibot'\n`;
 /**
  * Generate Valibot schemas and types
  * @param models - The models to generate the Valibot schemas and types for
@@ -30,18 +26,14 @@ export function valibot(models, type, comment) {
         }));
         return fields;
     });
-    // null exclude
-    const validFields = isFields(modelFields);
-    // group by model
-    const groupedByModel = groupByModel(validFields);
-    const valibots = Object.values(groupedByModel).map((fields) => {
+    const valibots = Object.values(groupByModel(isFields(modelFields))).map((fields) => {
         return {
             generateValibotSchema: schemas(fields, comment),
             generateValibotInfer: type ? inferInput(fields[0].modelName) : '',
         };
     });
     return [
-        VALIBOT_IMPORT,
+        `import * as v from 'valibot'`,
         '',
         valibots
             .flatMap(({ generateValibotSchema, generateValibotInfer }) => [generateValibotSchema, generateValibotInfer].filter(Boolean))

package/dist/generator/valibot/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { valibot } from './generator/valibot.js';
 import fsp from 'node:fs/promises';
 import pkg from '@prisma/generator-helper';
 import { fmt } from '../../shared/format/index.js';
+import { valibot } from './generator/valibot.js';
 const { generatorHandler } = pkg;
 export async function main(options) {
     const output = options.generator.output?.value ?? './valibot';

package/dist/generator/valibot/utils/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Generates a `v.InferInput` type for the specified model.
+ *
+ * @param modelName - The name of the model.
+ * @returns The generated TypeScript type definition line.
+ */
+export declare function inferInput(modelName: string): string;
+/**
+ * Generates Valibot property definitions from model fields.
+ *
+ * Filters out fields without validation, removes documentation tags like
+ * @relation, @v, @z, and optionally includes doc comments.
+ *
+ * @param modelFields - The list of model fields with metadata.
+ * @param comment - Whether to include documentation comments.
+ * @returns A string containing formatted Valibot property definitions.
+ */
+export declare function properties(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], comment: boolean): string;
+/**
+ * Parses documentation lines and filters out Valibot validation entries.
+ *
+ * Lines containing "@v." will be excluded.
+ *
+ * @param documentation - The raw documentation string.
+ * @returns An array of non-Valibot documentation lines.
+ */
+export declare function isValibotDocument(documentation?: string): string[];
+/**
+ * Extracts the Valibot validation expression from a documentation string.
+ *
+ * Searches for a line starting with "@v." and returns the expression that follows.
+ *
+ * @param documentation - The documentation string to search.
+ * @returns The Valibot expression without "@v." prefix, or null if not found.
+ */
+export declare function isValibot(documentation?: string): string | null;

package/dist/generator/valibot/utils/index.js

@@ -0,0 +1,61 @@
+/**
+ * Generates a `v.InferInput` type for the specified model.
+ *
+ * @param modelName - The name of the model.
+ * @returns The generated TypeScript type definition line.
+ */
+export function inferInput(modelName) {
+    return `export type ${modelName} = v.InferInput<typeof ${modelName}Schema>`;
+}
+/**
+ * Generates Valibot property definitions from model fields.
+ *
+ * Filters out fields without validation, removes documentation tags like
+ * @relation, @v, @z, and optionally includes doc comments.
+ *
+ * @param modelFields - The list of model fields with metadata.
+ * @param comment - Whether to include documentation comments.
+ * @returns A string containing formatted Valibot property definitions.
+ */
+export function properties(modelFields, comment) {
+    const fields = modelFields
+        .filter((field) => field.validation)
+        .map((field) => {
+        const cleanDoc = field.comment
+            .filter((line) => !(line.includes('@relation') || line.includes('@v') || line.includes('@z')))
+            .join('\n')
+            .trim();
+        const docComment = comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : '';
+        return `${docComment}  ${field.fieldName}: v.${field.validation}`;
+    })
+        .join(',\n');
+    return fields;
+}
+/**
+ * Parses documentation lines and filters out Valibot validation entries.
+ *
+ * Lines containing "@v." will be excluded.
+ *
+ * @param documentation - The raw documentation string.
+ * @returns An array of non-Valibot documentation lines.
+ */
+export function isValibotDocument(documentation) {
+    return (documentation
+        ?.split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.includes('@v.')) ?? []);
+}
+/**
+ * Extracts the Valibot validation expression from a documentation string.
+ *
+ * Searches for a line starting with "@v." and returns the expression that follows.
+ *
+ * @param documentation - The documentation string to search.
+ * @returns The Valibot expression without "@v." prefix, or null if not found.
+ */
+export function isValibot(documentation) {
+    if (!documentation)
+        return null;
+    const match = documentation.match(/@v\.(.+?)(?:\n|$)/);
+    return match ? match[1].trim() : null;
+}