sizuku 0.1.0 → 0.2.1

package/dist/src/generator/valibot/generator/valibot-code.js

@@ -0,0 +1,16 @@
+import { inferInput } from './infer-input.js';
+import { valibot } from './valibot.js';
+/**
+ * @param schema
+ * @param comment
+ * @param type
+ * @returns
+ */
+export function valibotCode(schema, comment, type) {
+    const valibotSchema = valibot(schema, comment);
+    if (type) {
+        const valibotInfer = inferInput(schema.name);
+        return `${valibotSchema}\n\n${valibotInfer}\n`;
+    }
+    return `${valibotSchema}\n`;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * @param schema
+ * @param config
+ * @returns
+ */
+export declare function valibot(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}, comment: boolean): string;

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

@@ -0,0 +1,11 @@
+import { fieldDefinitions } from '../../../shared/generator/field-definitions.js';
+import { schemaName } from '../../../shared/utils/index.js';
+/**
+ * @param schema
+ * @param config
+ * @returns
+ */
+export function valibot(schema, comment) {
+    const res = fieldDefinitions(schema, comment);
+    return `export const ${schemaName(schema.name)} = v.object({${res}})`;
+}

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

@@ -0,0 +1,9 @@
+import type { Result } from 'neverthrow';
+/**
+ * Generate Valibot schema
+ * @param code - The code to generate Valibot schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ */
+export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean): Promise<Result<void, Error>>;

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

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import { fmt } from '../../shared/format/index.js';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { buildSchemaExtractor } from '../../shared/helper/build-schema-extractor.js';
+import { createExtractFieldFromProperty } from '../../shared/helper/create-extract-field-from-property.js';
+import { createExtractFieldsFromCallExpression } from '../../shared/helper/create-extract-fields-from-call-expression.js';
+import { createExtractRelationFieldFromProperty } from '../../shared/helper/create-extract-relation-field-from-property.js';
+import { extractSchemas } from '../../shared/helper/extract-schemas.js';
+import { findObjectLiteralExpression } from '../../shared/helper/find-object-literal-expression.js';
+import { findObjectLiteralInArgs } from '../../shared/helper/find-object-literalIn-args.js';
+import { isRelationFunctionCall } from '../../shared/helper/is-relation-function.js';
+import { parseFieldComments } from '../../shared/utils/index.js';
+import { valibotCode } from './generator/valibot-code.js';
+/**
+ * Generate Valibot schema
+ * @param code - The code to generate Valibot schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ */
+export async function sizukuValibot(code, output, comment, type) {
+    const extractField = createExtractFieldFromProperty((lines) => parseFieldComments(lines, '@v.'));
+    const extractRelationField = createExtractRelationFieldFromProperty((lines) => parseFieldComments(lines, '@v.'), 'v');
+    const extractFieldsFromCall = createExtractFieldsFromCallExpression(extractField, extractRelationField, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall);
+    const extractSchema = buildSchemaExtractor(extractFieldsFromCall, extractField);
+    const valibotGeneratedCode = [
+        'import * as v from "valibot"',
+        '',
+        ...extractSchemas(code, extractSchema).map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
+    ].join('\n');
+    return await mkdir(path.dirname(output))
+        .andThen(() => fmt(valibotGeneratedCode))
+        .andThen((formatted) => writeFile(output, formatted));
+}

package/dist/src/generator/zod/generator/infer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param name
+ * @returns
+ */
+export declare function infer(name: string): string;

package/dist/src/generator/zod/generator/infer.js

@@ -0,0 +1,8 @@
+/**
+ * @param name
+ * @returns
+ */
+export function infer(name) {
+    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+    return `export type ${capitalizedName} = z.infer<typeof ${capitalizedName}Schema>`;
+}

package/dist/src/generator/zod/generator/zod-code.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Generates Zod code for a given schema and config.
+ *
+ * @function generateZodCode
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod code.
+ */
+export declare function zodCode(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}, comment: boolean, type: boolean): string;

package/dist/src/generator/zod/generator/zod-code.js

@@ -0,0 +1,18 @@
+import { infer } from './infer.js';
+import { zod } from './zod.js';
+/**
+ * Generates Zod code for a given schema and config.
+ *
+ * @function generateZodCode
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod code.
+ */
+export function zodCode(schema, comment, type) {
+    const zodSchema = zod(schema, comment);
+    if (type) {
+        const zInfer = infer(schema.name);
+        return `${zodSchema}\n\n${zInfer}\n`;
+    }
+    return `${zodSchema}\n`;
+}

package/dist/src/generator/zod/generator/zod.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates a Zod schema for a given schema and config.
+ *
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod schema.
+ */
+export declare function zod(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}, comment: boolean): string;

package/dist/src/generator/zod/generator/zod.js

@@ -0,0 +1,12 @@
+import { fieldDefinitions } from '../../../shared/generator/field-definitions.js';
+import { schemaName } from '../../../shared/utils/index.js';
+/**
+ * Generates a Zod schema for a given schema and config.
+ *
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod schema.
+ */
+export function zod(schema, comment) {
+    return `export const ${schemaName(schema.name)} = z.object({${fieldDefinitions(schema, comment)}})`;
+}

package/dist/src/generator/zod/index.d.ts

@@ -0,0 +1,10 @@
+import type { Result } from 'neverthrow';
+/**
+ * Generate Zod schema
+ * @param code - The code to generate Zod schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ * @param zod - The Zod version to use
+ */
+export declare function sizukuZod(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, zod?: 'v4' | 'mini' | '@hono/zod-openapi'): Promise<Result<void, Error>>;

package/dist/src/generator/zod/index.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { fmt } from '../../shared/format/index.js';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { buildSchemaExtractor } from '../../shared/helper/build-schema-extractor.js';
+import { createExtractFieldFromProperty } from '../../shared/helper/create-extract-field-from-property.js';
+import { createExtractFieldsFromCallExpression } from '../../shared/helper/create-extract-fields-from-call-expression.js';
+import { createExtractRelationFieldFromProperty } from '../../shared/helper/create-extract-relation-field-from-property.js';
+import { extractSchemas } from '../../shared/helper/extract-schemas.js';
+import { findObjectLiteralExpression } from '../../shared/helper/find-object-literal-expression.js';
+import { findObjectLiteralInArgs } from '../../shared/helper/find-object-literalIn-args.js';
+import { isRelationFunctionCall } from '../../shared/helper/is-relation-function.js';
+import { parseFieldComments } from '../../shared/utils/index.js';
+import { zodCode } from './generator/zod-code.js';
+/**
+ * Generate Zod schema
+ * @param code - The code to generate Zod schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ * @param zod - The Zod version to use
+ */
+export async function sizukuZod(code, output, comment, type, zod) {
+    const extractField = createExtractFieldFromProperty((lines) => parseFieldComments(lines, '@z.'));
+    const extractRelationField = createExtractRelationFieldFromProperty((lines) => parseFieldComments(lines, '@z.'), 'z');
+    const extractFieldsFromCall = createExtractFieldsFromCallExpression(extractField, extractRelationField, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall);
+    const extractSchema = buildSchemaExtractor(extractFieldsFromCall, extractField);
+    const importLine = zod === 'mini'
+        ? `import * as z from 'zod/mini'`
+        : zod === '@hono/zod-openapi'
+            ? `import { z } from '@hono/zod-openapi'`
+            : `import * as z from 'zod'`;
+    const zodGeneratedCode = [
+        importLine,
+        '',
+        ...extractSchemas(code, extractSchema).map((schema) => zodCode(schema, comment ?? false, type ?? false)),
+    ].join('\n');
+    return await mkdir(path.dirname(output))
+        .andThen(() => fmt(zodGeneratedCode))
+        .andThen((formatted) => writeFile(output, formatted));
+}

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+import type { Result } from 'neverthrow';
+import type { Config } from './config/index.js';
+/**
+ * Generate schemas from Drizzle table definitions.
+ *
+ * @param code - The code lines to process.
+ * @param config - The configuration object.
+ * @returns A Result indicating success or failure.
+ */
+export declare function generateSchemas(code: string[], config: Config): Promise<Result<void, Error>>;

package/dist/src/index.js

@@ -0,0 +1,35 @@
+import { err, ok } from 'neverthrow';
+import { sizukuMermaidER } from './generator/mermaid-er/index.js';
+import { sizukuValibot } from './generator/valibot/index.js';
+import { sizukuZod } from './generator/zod/index.js';
+/**
+ * Generate schemas from Drizzle table definitions.
+ *
+ * @param code - The code lines to process.
+ * @param config - The configuration object.
+ * @returns A Result indicating success or failure.
+ */
+export async function generateSchemas(code, config) {
+    if (!config.input) {
+        return err(new Error('input is not found'));
+    }
+    const zodResult = config.zod?.output
+        ? await sizukuZod(code, config.zod.output, config.zod.comment, config.zod.type, config.zod.zod)
+        : ok(undefined);
+    if (zodResult.isErr()) {
+        return err(zodResult.error);
+    }
+    const valibotResult = config.valibot?.output
+        ? await sizukuValibot(code, config.valibot.output, config.valibot.comment, config.valibot.type)
+        : ok(undefined);
+    if (valibotResult.isErr()) {
+        return err(valibotResult.error);
+    }
+    const mermaidResult = config.mermaid?.output
+        ? await sizukuMermaidER(code, config.mermaid.output)
+        : ok(undefined);
+    if (mermaidResult.isErr()) {
+        return err(mermaidResult.error);
+    }
+    return ok(undefined);
+}

package/dist/src/shared/format/index.d.ts

@@ -0,0 +1,2 @@
+import { ResultAsync } from 'neverthrow';
+export declare function fmt(code: string): ResultAsync<string, Error>;

package/dist/src/shared/format/index.js

@@ -0,0 +1,10 @@
+import { ResultAsync } from 'neverthrow';
+import { format } from 'prettier';
+export function fmt(code) {
+    return ResultAsync.fromPromise(format(code, {
+        parser: 'typescript',
+        printWidth: 100,
+        singleQuote: true,
+        semi: false,
+    }), (e) => new Error(String(e)));
+}

package/dist/src/shared/fs/index.d.ts

@@ -0,0 +1,2 @@
+import type { Result } from 'neverthrow';
+export declare function readFileSync(path: string): Result<string, Error>;

package/dist/src/shared/fs/index.js

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+import { err, ok } from 'neverthrow';
+export function readFileSync(path) {
+    try {
+        return ok(fs.readFileSync(path, 'utf-8'));
+    }
+    catch (e) {
+        return err(new Error(String(e)));
+    }
+}

package/dist/src/shared/fsp/index.d.ts

@@ -0,0 +1,3 @@
+import { ResultAsync } from 'neverthrow';
+export declare function mkdir(path: string): ResultAsync<string | undefined, Error>;
+export declare function writeFile(path: string, data: string): ResultAsync<void, Error>;

package/dist/src/shared/fsp/index.js

@@ -0,0 +1,8 @@
+import fsp from 'node:fs/promises';
+import { ResultAsync } from 'neverthrow';
+export function mkdir(path) {
+    return ResultAsync.fromPromise(fsp.mkdir(path, { recursive: true }), (e) => new Error(String(e)));
+}
+export function writeFile(path, data) {
+    return ResultAsync.fromPromise(fsp.writeFile(path, data), (e) => new Error(String(e)));
+}

package/dist/src/shared/generator/field-definitions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param schema
+ * @returns
+ */
+export declare function fieldDefinitions(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}, comment: boolean): string;

package/dist/src/shared/generator/field-definitions.js

@@ -0,0 +1,12 @@
+/**
+ * @param schema
+ * @returns
+ */
+export function fieldDefinitions(schema, comment) {
+    return schema.fields
+        .map(({ name, definition, description }) => {
+        const commentCode = description && comment ? `/**\n* ${description}\n*/\n` : '';
+        return `${commentCode}${name}:${definition}`;
+    })
+        .join(',\n');
+}

package/dist/src/shared/helper/build-schema-extractor.d.ts

@@ -0,0 +1,25 @@
+import type { CallExpression } from 'ts-morph';
+import { Node } from 'ts-morph';
+/**
+ * Creates a schema extractor from customizable strategies.
+ *
+ * @param extractFieldsFromCall - Function to extract fields from a call expression (e.g. mysqlTable(...)).
+ * @param extractFieldFromProperty - Function to extract a single field from an object literal property.
+ * @returns A function that extracts a schema from a variable declaration node.
+ */
+export declare function buildSchemaExtractor(extractFieldsFromCall: (call: CallExpression, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+}[], extractFieldFromProperty: (prop: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null): (declaration: Node, sourceText: string) => {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+} | null;

package/dist/src/shared/helper/build-schema-extractor.js

@@ -0,0 +1,33 @@
+import { Node } from 'ts-morph';
+import { isRelationFunctionCall } from '../../shared/helper/is-relation-function.js';
+/**
+ * Creates a schema extractor from customizable strategies.
+ *
+ * @param extractFieldsFromCall - Function to extract fields from a call expression (e.g. mysqlTable(...)).
+ * @param extractFieldFromProperty - Function to extract a single field from an object literal property.
+ * @returns A function that extracts a schema from a variable declaration node.
+ */
+export function buildSchemaExtractor(extractFieldsFromCall, extractFieldFromProperty) {
+    return (declaration, sourceText) => {
+        if (!Node.isVariableDeclaration(declaration))
+            return null;
+        const name = declaration.getName();
+        if (!name)
+            return null;
+        const initializer = declaration.getInitializer();
+        if (Node.isCallExpression(initializer)) {
+            if (isRelationFunctionCall(initializer))
+                return null;
+            const fields = extractFieldsFromCall(initializer, sourceText);
+            return { name, fields };
+        }
+        if (Node.isObjectLiteralExpression(initializer)) {
+            const fields = initializer
+                .getProperties()
+                .map((prop) => extractFieldFromProperty(prop, sourceText))
+                .filter((field) => field !== null);
+            return { name, fields };
+        }
+        return { name, fields: [] };
+    };
+}

package/dist/src/shared/helper/create-extract-field-from-property.d.ts

@@ -0,0 +1,15 @@
+import { Node } from 'ts-morph';
+/**
+ * Creates a field extractor function using a custom parseFieldComments implementation.
+ *
+ * @param parseFieldComments - A function that parses comment lines into { definition, description }
+ * @returns A property node extractor function.
+ */
+export declare function createExtractFieldFromProperty(parseFieldComments: (commentLines: string[]) => {
+    definition: string;
+    description?: string;
+}): (property: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null;

package/dist/src/shared/helper/create-extract-field-from-property.js

@@ -0,0 +1,20 @@
+import { Node } from 'ts-morph';
+import { extractFieldComments } from '../../shared/utils/index.js';
+/**
+ * Creates a field extractor function using a custom parseFieldComments implementation.
+ *
+ * @param parseFieldComments - A function that parses comment lines into { definition, description }
+ * @returns A property node extractor function.
+ */
+export function createExtractFieldFromProperty(parseFieldComments) {
+    return (property, sourceText) => {
+        if (!Node.isPropertyAssignment(property))
+            return null;
+        const name = property.getName();
+        if (!name)
+            return null;
+        const commentLines = extractFieldComments(sourceText, property.getStart());
+        const { definition, description } = parseFieldComments(commentLines);
+        return { name, definition, description };
+    };
+}

package/dist/src/shared/helper/create-extract-fields-from-call-expression.d.ts

@@ -0,0 +1,14 @@
+import type { CallExpression, Node, ObjectLiteralExpression } from 'ts-morph';
+export declare function createExtractFieldsFromCallExpression(extractFieldFromProperty: (property: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null, extractRelationFieldFromProperty: (property: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null, findObjectLiteralExpression: (expr: Node) => ObjectLiteralExpression | null, findObjectLiteralInArgs: (call: CallExpression, finder: (expr: Node) => ObjectLiteralExpression | null) => ObjectLiteralExpression | null, isRelationFunctionCall: (call: CallExpression) => boolean): (callExpr: CallExpression, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+}[];

package/dist/src/shared/helper/create-extract-fields-from-call-expression.js

@@ -0,0 +1,14 @@
+export function createExtractFieldsFromCallExpression(extractFieldFromProperty, extractRelationFieldFromProperty, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall) {
+    return (callExpr, sourceText) => {
+        const objectLiteral = findObjectLiteralInArgs(callExpr, findObjectLiteralExpression);
+        if (!objectLiteral)
+            return [];
+        const isRelation = isRelationFunctionCall(callExpr);
+        return objectLiteral
+            .getProperties()
+            .map((prop) => isRelation
+            ? extractRelationFieldFromProperty(prop, sourceText)
+            : extractFieldFromProperty(prop, sourceText))
+            .filter((field) => field !== null);
+    };
+}

package/dist/src/shared/helper/create-extract-relation-field-from-property.d.ts

@@ -0,0 +1,12 @@
+import { Node } from 'ts-morph';
+export declare const createExtractRelationFieldFromProperty: (parseFieldComments: (lines: string[]) => {
+    definition: string;
+    description?: string;
+}, prefix: "v" | "z") => (property: Node, sourceText: string) => {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}["fields"][0] | null;

package/dist/src/shared/helper/create-extract-relation-field-from-property.js

@@ -0,0 +1,27 @@
+import { Node } from 'ts-morph';
+import { extractFieldComments, schemaName } from '../utils/index.js';
+export const createExtractRelationFieldFromProperty = (parseFieldComments, prefix) => {
+    return (property, sourceText) => {
+        if (!Node.isPropertyAssignment(property))
+            return null;
+        const name = property.getName();
+        if (!name)
+            return null;
+        const init = property.getInitializer();
+        if (!Node.isCallExpression(init))
+            return { name, definition: '', description: undefined };
+        const expr = init.getExpression();
+        if (!Node.isIdentifier(expr))
+            return { name, definition: '', description: undefined };
+        const fnName = expr.getText();
+        const args = init.getArguments();
+        if (!(args.length && Node.isIdentifier(args[0]))) {
+            return { name, definition: '', description: undefined };
+        }
+        const refTable = args[0].getText();
+        const schema = schemaName(refTable);
+        const definition = fnName === 'many' ? `${prefix}.array(${schema})` : fnName === 'one' ? schema : '';
+        const { description } = parseFieldComments(extractFieldComments(sourceText, property.getStart()));
+        return { name, definition, description };
+    };
+};

package/dist/src/shared/helper/extract-schemas.d.ts

@@ -0,0 +1,16 @@
+import type { Node } from 'ts-morph';
+export declare function extractSchemas(lines: string[], extractFn: (declaration: Node, sourceText: string) => {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+} | null): {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}[];

package/dist/src/shared/helper/extract-schemas.js

@@ -0,0 +1,19 @@
+import { Project } from 'ts-morph';
+export function extractSchemas(lines, extractFn) {
+    const sourceCode = lines.join('\n');
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            allowJs: true,
+            skipLibCheck: true,
+        },
+    });
+    const sourceFile = project.createSourceFile('temp.ts', sourceCode);
+    const sourceText = sourceFile.getFullText();
+    return sourceFile
+        .getVariableStatements()
+        .filter((stmt) => stmt.hasExportKeyword())
+        .flatMap((stmt) => stmt.getDeclarations())
+        .map((decl) => extractFn(decl, sourceText))
+        .filter((schema) => schema !== null);
+}

package/dist/src/shared/helper/find-object-literal-expression.d.ts

@@ -0,0 +1,12 @@
+import type { ObjectLiteralExpression } from 'ts-morph';
+import { Node } from 'ts-morph';
+/**
+ * Recursively extracts an `ObjectLiteralExpression` from a given AST node.
+ *
+ * Supports direct object literals, parenthesized expressions,
+ * arrow functions returning object literals (including wrapped and block bodies).
+ *
+ * @param expr - The root `Node` to search.
+ * @returns The found `ObjectLiteralExpression`, or `null` if not found.
+ */
+export declare function findObjectLiteralExpression(expr: Node): ObjectLiteralExpression | null;

package/dist/src/shared/helper/find-object-literal-expression.js

@@ -0,0 +1,31 @@
+import { Node } from 'ts-morph';
+/**
+ * Recursively extracts an `ObjectLiteralExpression` from a given AST node.
+ *
+ * Supports direct object literals, parenthesized expressions,
+ * arrow functions returning object literals (including wrapped and block bodies).
+ *
+ * @param expr - The root `Node` to search.
+ * @returns The found `ObjectLiteralExpression`, or `null` if not found.
+ */
+export function findObjectLiteralExpression(expr) {
+    if (Node.isObjectLiteralExpression(expr))
+        return expr;
+    if (Node.isParenthesizedExpression(expr))
+        return findObjectLiteralExpression(expr.getExpression());
+    if (Node.isArrowFunction(expr)) {
+        const body = expr.getBody();
+        if (Node.isObjectLiteralExpression(body))
+            return body;
+        if (Node.isParenthesizedExpression(body))
+            return findObjectLiteralExpression(body.getExpression());
+        if (Node.isBlock(body)) {
+            const ret = body.getStatements().find(Node.isReturnStatement);
+            if (ret && Node.isReturnStatement(ret)) {
+                const re = ret.getExpression();
+                return re && Node.isObjectLiteralExpression(re) ? re : null;
+            }
+        }
+    }
+    return null;
+}

package/dist/src/shared/helper/find-object-literalIn-args.d.ts

@@ -0,0 +1,2 @@
+import type { CallExpression, Node, ObjectLiteralExpression } from 'ts-morph';
+export declare function findObjectLiteralInArgs(call: CallExpression, finder: (expr: Node) => ObjectLiteralExpression | null): ObjectLiteralExpression | null;

package/dist/src/shared/helper/find-object-literalIn-args.js

@@ -0,0 +1,8 @@
+export function findObjectLiteralInArgs(call, finder) {
+    for (const arg of call.getArguments()) {
+        const obj = finder(arg);
+        if (obj)
+            return obj;
+    }
+    return null;
+}

package/dist/src/shared/helper/is-relation-function.d.ts

@@ -0,0 +1,10 @@
+import type { CallExpression } from 'ts-morph';
+/**
+ * Determines whether a given `CallExpression` is a relation-related function call.
+ *
+ * This checks if the function name is either `"relations"` or contains the substring `"relation"`.
+ *
+ * @param callExpr - The call expression node to check.
+ * @returns `true` if the function is a relation function; otherwise, `false`.
+ */
+export declare function isRelationFunctionCall(callExpr: CallExpression): boolean;