hekireki 0.2.5 → 0.2.7

package/README.md

@@ -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)

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

@@ -2,70 +2,107 @@ import fsp from 'node:fs/promises';
 import { join } from 'node:path';
 import { snakeCase } from '../../../shared/utils/index.js';
 import { prismaTypeToEctoType } from '../utils/prisma-type-to-ecto-type.js';
-/* ───────── Utilities ────────────────────────── */
-/** UUID PK → :binary_id / otherwise :string */
-function getPrimaryKeyType(field) {
+function getPrimaryKeyConfig(field) {
+    if (field.type === 'String' &&
+        field.default &&
+        typeof field.default === 'object' &&
+        'name' in field.default &&
+        field.default.name === 'uuid') {
+        return {
+            line: '@primary_key {:id, :binary_id, autogenerate: true}',
+            typeSpec: 'Ecto.UUID.t()',
+            omitIdFieldInSchema: true,
+        };
+    }
+    return {
+        line: '@primary_key false',
+        typeSpec: 'String.t()',
+        omitIdFieldInSchema: false,
+    };
+}
+function getFieldDefaultOption(field) {
     const def = field.default;
-    return def && typeof def === 'object' && 'name' in def && def.name === 'uuid'
-        ? 'binary_id'
-        : 'string';
+    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;
 }
-/** Convert readonly models to mutable copies */
-function makeMutable(models) {
-    return models.map((m) => ({
-        ...m,
-        fields: m.fields?.map((f) => ({ ...f })) ?? [],
-    }));
+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()';
+    }
 }
-/* ───────── Main generator ───────────────────── */
-export function ectoSchemas(models, app) {
-    const mutableModels = makeMutable(models);
-    /** Timestamp column aliases (snake_case & camelCase) */
+function buildTimestampsLine(fields) {
     const insertedAliases = ['inserted_at', 'created_at', 'createdAt'];
     const updatedAliases = ['updated_at', 'modified_at', 'updatedAt', 'modifiedAt'];
-    return mutableModels
+    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) => {
-        /* ── Primary-key handling ─────────────────── */
-        const idFields = model.fields.filter((f) => f.isId);
-        const isCompositePK = model.primaryKey && model.primaryKey.fields.length > 1;
-        if (!(idFields.length || isCompositePK))
+        const idField = model.fields.find((f) => f.isId);
+        if (!idField)
             return '';
-        const pkField = idFields[0];
-        const pkType = pkField ? getPrimaryKeyType(pkField) : 'id';
-        /* ── Timestamp field detection ────────────── */
-        const insertedField = model.fields.find((f) => insertedAliases.includes(f.name));
-        const updatedField = model.fields.find((f) => updatedAliases.includes(f.name));
-        /** Columns removed from explicit `field/3` declarations */
-        const excludedNames = [
-            ...(insertedField ? [insertedField.name] : []),
-            ...(updatedField ? [updatedField.name] : []),
+        const pk = getPrimaryKeyConfig(idField);
+        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}`,
+            ...schemaFieldsRaw.map((f) => `${f.name}: ${ectoTypeToTypespec(prismaTypeToEctoType(f.type))}`),
         ];
-        /* ── Plain fields (no relations / no timestamps) ─ */
-        const fields = model.fields.filter((f) => !(f.relationName || excludedNames.includes(f.name)));
-        /* ── Build timestamps() line (const-only) ─────── */
-        const timestampsLine = (() => {
-            if (!(insertedField || updatedField))
-                return '';
-            const hasCustom = (insertedField && insertedField.name !== 'inserted_at') ||
-                (updatedField && updatedField.name !== 'updated_at');
-            if (!hasCustom)
-                return '    timestamps()'; // both defaults → short form
-            // Always include both keys when custom names are involved
-            const insertedName = insertedField ? insertedField.name : 'inserted_at';
-            const updatedName = updatedField ? updatedField.name : 'updated_at';
-            return `    timestamps(inserted_at: :${insertedName}, updated_at: :${updatedName})`;
-        })();
-        /* ── Assemble final module code ───────────── */
+        const typeSpecLines = [
+            '  @type t :: %__MODULE__{',
+            ...typeSpecFields.map((line, i) => {
+                const isLast = i === typeSpecFields.length - 1;
+                return `          ${line}${isLast ? '' : ','}`;
+            }),
+            '        }',
+        ];
+        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`,
             '  use Ecto.Schema',
-            '  @primary_key false',
+            '',
+            `  ${pk.line}`,
+            '',
+            ...typeSpecLines,
+            '',
             `  schema "${snakeCase(model.name)}" do`,
-            ...fields.map((f) => {
-                const type = f.isId ? pkType : prismaTypeToEctoType(f.type);
-                const primary = f.isId && !isCompositePK ? ', primary_key: true' : '';
-                return `    field(:${f.name}, :${type}${primary})`;
-            }),
+            ...schemaFields,
             ...(timestampsLine ? [timestampsLine] : []),
             '  end',
             'end',
@@ -75,11 +112,9 @@ export function ectoSchemas(models, app) {
         .filter(Boolean)
         .join('\n\n');
 }
-/* ───────── File writer ───────────────────────── */
 export async function writeEctoSchemasToFiles(models, app, outDir) {
-    const mutableModels = makeMutable(models);
     await fsp.mkdir(outDir, { recursive: true });
-    for (const model of mutableModels) {
+    for (const model of models) {
         const code = ectoSchemas([model], app);
         if (!code.trim())
             continue;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hekireki",
   "type": "module",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "license": "MIT",
   "description": "Hekireki is a tool that generates validation schemas for Zod and Valibot, as well as ER diagrams, from Prisma schemas annotated with comments.",
   "keywords": [