hekireki 0.2.6 → 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

@@ -20,6 +20,48 @@ 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 +69,14 @@ 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 +86,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 +103,7 @@ export function ectoSchemas(models, app) {
             '',
             `  schema "${snakeCase(model.name)}" do`,
             ...schemaFields,
+            ...(timestampsLine ? [timestampsLine] : []),
             '  end',
             'end',
         ];
@@ -62,26 +112,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hekireki",
   "type": "module",
-  "version": "0.2.6",
+  "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": [