hekireki 0.7.3 → 0.7.4

package/README.md

@@ -257,7 +257,7 @@ export const UserSchema = v.object({
   name: v.pipe(v.string(), v.minLength(1), v.maxLength(50)),
 })
 
-export type User = v.InferInput<typeof UserSchema>
+export type User = v.InferOutput<typeof UserSchema>
 
 export const PostSchema = v.object({
   /**
@@ -278,21 +278,21 @@ export const PostSchema = v.object({
   userId: v.pipe(v.string(), v.uuid()),
 })
 
-export type Post = v.InferInput<typeof PostSchema>
+export type Post = v.InferOutput<typeof PostSchema>
 
 export const UserRelationsSchema = v.object({
   ...UserSchema.entries,
   posts: v.array(PostSchema),
 })
 
-export type UserRelations = v.InferInput<typeof UserRelationsSchema>
+export type UserRelations = v.InferOutput<typeof UserRelationsSchema>
 
 export const PostRelationsSchema = v.object({
   ...PostSchema.entries,
   user: UserSchema,
 })
 
-export type PostRelations = v.InferInput<typeof PostRelationsSchema>
+export type PostRelations = v.InferOutput<typeof PostRelationsSchema>
 ```
 
 ### ArkType
@@ -329,26 +329,38 @@ export type Post = typeof PostSchema.infer
 import { Schema } from 'effect'
 
 export const UserSchema = Schema.Struct({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: Schema.UUID,
-  /** Display name */
+  /**
+   * Display name
+   */
   name: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(50)),
 })
 
-export type User = Schema.Schema.Type<typeof UserSchema>
+export type UserEncoded = typeof UserSchema.Encoded
 
 export const PostSchema = Schema.Struct({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: Schema.UUID,
-  /** Article title */
+  /**
+   * Article title
+   */
   title: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(100)),
-  /** Body content (no length limit) */
+  /**
+   * Body content (no length limit)
+   */
   content: Schema.String,
-  /** Foreign key referencing User.id */
+  /**
+   * Foreign key referencing User.id
+   */
   userId: Schema.UUID,
 })
 
-export type Post = Schema.Schema.Type<typeof PostSchema>
+export type PostEncoded = typeof PostSchema.Encoded
 ```
 
 ### TypeBox

package/dist/generator/effect/index.js

@@ -7,14 +7,14 @@ import pkg from "@prisma/generator-helper";
 
 //#region src/helper/effect.ts
 function makeEffectInfer(modelName) {
-	return `export type ${modelName} = Schema.Schema.Type<typeof ${modelName}Schema>`;
+	return `export type ${modelName}Encoded = typeof ${modelName}Schema.Encoded`;
 }
 function makeEffectSchema(modelName, fields) {
 	return `export const ${modelName}Schema = Schema.Struct({\n${fields}\n})`;
 }
 function makeEffectProperties(fields, comment) {
 	return fields.map((field) => {
-		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : ""}  ${field.fieldName}: ${field.validation ?? "Schema.Unknown"},`;
+		return `${comment && field.comment.length > 0 ? `  /**\n${field.comment.map((c) => `   * ${c}`).join("\n")}\n   */\n` : ""}  ${field.fieldName}: ${field.validation ?? "Schema.Unknown"},`;
 	}).join("\n");
 }
 function makeEffectEnumExpression(values) {
@@ -37,7 +37,7 @@ function makeEffectSchemas(modelFields, comment) {
 function makeEffectRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const fields = `${`...${model.name}Schema.fields,`}${relProps.map((r) => `${r.key}:${r.isMany ? `Schema.Array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("")}`;
-	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = Schema.Schema.Type<typeof ${model.name}RelationsSchema>` : "";
+	const typeLine = options?.includeType ? `\n\nexport type ${model.name}RelationsEncoded = typeof ${model.name}RelationsSchema.Encoded` : "";
 	return `export const ${model.name}RelationsSchema = Schema.Struct({${fields}})${typeLine}`;
 }
 function effect(models, type, comment, enums) {

package/dist/generator/valibot/index.js

@@ -7,7 +7,7 @@ import pkg from "@prisma/generator-helper";
 
 //#region src/helper/valibot.ts
 function makeValibotInfer(modelName) {
-	return `export type ${modelName} = v.InferInput<typeof ${modelName}Schema>`;
+	return `export type ${modelName} = v.InferOutput<typeof ${modelName}Schema>`;
 }
 function makeValibotSchema(modelName, fields) {
 	return `export const ${modelName}Schema = v.object({\n${fields}\n})`;
@@ -33,7 +33,7 @@ function makeValibotRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const base = `  ...${model.name}Schema.entries,`;
 	const rels = relProps.map((r) => `  ${r.key}: ${r.isMany ? `v.array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("\n");
-	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = v.InferInput<typeof ${model.name}RelationsSchema>` : "";
+	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = v.InferOutput<typeof ${model.name}RelationsSchema>` : "";
 	return `export const ${model.name}RelationsSchema = v.object({\n${base}\n${rels}\n})${typeLine}`;
 }
 function valibot(models, type, comment, enums) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hekireki",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Hekireki is a tool that generates validation schemas for Zod, Valibot, ArkType, and Effect Schema, as well as ER diagrams and DBML, from Prisma schemas annotated with comments.",
   "keywords": [
     "ajv",