@effectify/prisma 1.0.1 → 1.1.0

package/dist/src/schema-generator/prisma/type.d.ts

@@ -0,0 +1,108 @@
+import type { DMMF } from "@prisma/generator-helper";
+/**
+ * Check if a field is a UUID using native DMMF type information
+ * 3-tier detection: native type � documentation � field name patterns
+ */
+export declare function isUuidField(field: DMMF.Field): boolean;
+/**
+ * Get the database column name for a field (respects @map directive)
+ */
+export declare function getFieldDbName(field: DMMF.Field): string;
+/**
+ * Check if field has a default value using native DMMF property
+ */
+export declare function hasDefaultValue(field: DMMF.Field): boolean;
+/**
+ * Check if field is an ID field using native DMMF property
+ */
+export declare function isIdField(field: DMMF.Field): boolean;
+/**
+ * Check if field is required using native DMMF property
+ */
+export declare function isRequiredField(field: DMMF.Field): boolean;
+/**
+ * Check if field is a list/array using native DMMF property
+ */
+export declare function isListField(field: DMMF.Field): boolean;
+/**
+ * Filter models to exclude internal models (starting with _)
+ */
+export declare function filterInternalModels(models: readonly DMMF.Model[]): DMMF.ReadonlyDeep<{
+    name: string;
+    dbName: string | null;
+    schema: string | null;
+    fields: DMMF.Field[];
+    uniqueFields: string[][];
+    uniqueIndexes: DMMF.uniqueIndex[];
+    documentation?: string;
+    primaryKey: DMMF.PrimaryKey | null;
+    isGenerated?: boolean;
+}>[];
+/**
+ * Filter fields to only include scalar and enum fields (exclude relations)
+ */
+export declare function filterSchemaFields(fields: readonly DMMF.Field[]): DMMF.ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    type: string;
+    nativeType?: [string, string[]] | null;
+    dbName?: string | null;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefault | DMMF.FieldDefaultScalar | DMMF.FieldDefaultScalar[];
+    relationFromFields?: string[];
+    relationToFields?: string[];
+    relationOnDelete?: string;
+    relationOnUpdate?: string;
+    relationName?: string;
+    documentation?: string;
+}>[];
+/**
+ * Get the database table name for a model (respects @@map directive)
+ */
+export declare function getModelDbName(model: DMMF.Model): string;
+/**
+ * Sort models alphabetically for deterministic output
+ */
+export declare function sortModels(models: readonly DMMF.Model[]): DMMF.ReadonlyDeep<{
+    name: string;
+    dbName: string | null;
+    schema: string | null;
+    fields: DMMF.Field[];
+    uniqueFields: string[][];
+    uniqueIndexes: DMMF.uniqueIndex[];
+    documentation?: string;
+    primaryKey: DMMF.PrimaryKey | null;
+    isGenerated?: boolean;
+}>[];
+/**
+ * Sort fields alphabetically for deterministic output
+ */
+export declare function sortFields(fields: readonly DMMF.Field[]): DMMF.ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    type: string;
+    nativeType?: [string, string[]] | null;
+    dbName?: string | null;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefault | DMMF.FieldDefaultScalar | DMMF.FieldDefaultScalar[];
+    relationFromFields?: string[];
+    relationToFields?: string[];
+    relationOnDelete?: string;
+    relationOnUpdate?: string;
+    relationName?: string;
+    documentation?: string;
+}>[];

package/dist/src/schema-generator/prisma/type.js

@@ -0,0 +1,85 @@
+/**
+ * Check if a field is a UUID using native DMMF type information
+ * 3-tier detection: native type � documentation � field name patterns
+ */
+export function isUuidField(field) {
+    // 1. Check native type (most reliable)
+    if (field.nativeType?.[0] === "Uuid") {
+        return true;
+    }
+    // 2. Check documentation for @db.Uuid
+    if (field.documentation?.includes("@db.Uuid")) {
+        return true;
+    }
+    // 3. Fallback: Field name patterns (only for String type)
+    if (field.type !== "String") {
+        return false;
+    }
+    const uuidFieldPatterns = [
+        /^id$/, // Primary ID fields
+        /_id$/, // Foreign key ID fields
+        /^.*_uuid$/, // uuid suffix
+        /^uuid$/, // Direct uuid fields
+    ];
+    return uuidFieldPatterns.some((pattern) => pattern.test(field.name));
+}
+/**
+ * Get the database column name for a field (respects @map directive)
+ */
+export function getFieldDbName(field) {
+    return field.dbName ?? field.name;
+}
+/**
+ * Check if field has a default value using native DMMF property
+ */
+export function hasDefaultValue(field) {
+    return field.hasDefaultValue === true;
+}
+/**
+ * Check if field is an ID field using native DMMF property
+ */
+export function isIdField(field) {
+    return field.isId === true;
+}
+/**
+ * Check if field is required using native DMMF property
+ */
+export function isRequiredField(field) {
+    return field.isRequired === true;
+}
+/**
+ * Check if field is a list/array using native DMMF property
+ */
+export function isListField(field) {
+    return field.isList === true;
+}
+/**
+ * Filter models to exclude internal models (starting with _)
+ */
+export function filterInternalModels(models) {
+    return models.filter((model) => !model.name.startsWith("_"));
+}
+/**
+ * Filter fields to only include scalar and enum fields (exclude relations)
+ */
+export function filterSchemaFields(fields) {
+    return fields.filter((field) => field.kind === "scalar" || field.kind === "enum");
+}
+/**
+ * Get the database table name for a model (respects @@map directive)
+ */
+export function getModelDbName(model) {
+    return model.dbName ?? model.name;
+}
+/**
+ * Sort models alphabetically for deterministic output
+ */
+export function sortModels(models) {
+    return models.slice().sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Sort fields alphabetically for deterministic output
+ */
+export function sortFields(fields) {
+    return fields.slice().sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/src/schema-generator/utils/annotations.d.ts

@@ -0,0 +1,32 @@
+import type { DMMF } from "@prisma/generator-helper";
+/**
+ * @customType Annotation Parser
+ *
+ * Allows overriding Effect Schema types for Prisma-supported fields.
+ *
+ * WORKS FOR: Prisma scalar types (String, Int, Boolean, DateTime, etc.)
+ *
+ * USE CASES:
+ *   // Email validation for String field
+ *   /// @customType(Schema.String.pipe(Schema.email()))
+ *   email String
+ *
+ *   // Positive number constraint for Int field
+ *   /// @customType(Schema.Number.pipe(Schema.positive()))
+ *   age Int
+ *
+ *   // Custom branded type
+ *   /// @customType(Schema.String.pipe(Schema.brand('UserId')))
+ *   userId String
+ *
+ * @param field - Prisma DMMF field
+ * @returns Extracted type string or null if no annotation found
+ */
+export declare function extractEffectTypeOverride(field: DMMF.Field): string | null;
+/**
+ * Check if field has any custom type annotations
+ *
+ * @param fields - Array of Prisma fields
+ * @returns true if any field uses custom types in @effectType
+ */
+export declare function hasCustomTypeAnnotations(fields: readonly DMMF.Field[]): boolean;

package/dist/src/schema-generator/utils/annotations.js

@@ -0,0 +1,79 @@
+/**
+ * @customType Annotation Parser
+ *
+ * Allows overriding Effect Schema types for Prisma-supported fields.
+ *
+ * WORKS FOR: Prisma scalar types (String, Int, Boolean, DateTime, etc.)
+ *
+ * USE CASES:
+ *   // Email validation for String field
+ *   /// @customType(Schema.String.pipe(Schema.email()))
+ *   email String
+ *
+ *   // Positive number constraint for Int field
+ *   /// @customType(Schema.Number.pipe(Schema.positive()))
+ *   age Int
+ *
+ *   // Custom branded type
+ *   /// @customType(Schema.String.pipe(Schema.brand('UserId')))
+ *   userId String
+ *
+ * @param field - Prisma DMMF field
+ * @returns Extracted type string or null if no annotation found
+ */
+export function extractEffectTypeOverride(field) {
+    if (!field.documentation)
+        return null;
+    // Match @customType annotation - handle balanced parentheses
+    const annotationMatch = field.documentation.match(/@customType\s*\(/);
+    if (!annotationMatch)
+        return null;
+    // Find the matching closing parenthesis
+    const startIdx = field.documentation.indexOf("@customType(") + "@customType(".length;
+    let parenCount = 1;
+    let endIdx = startIdx;
+    for (let i = startIdx; i < field.documentation.length && parenCount > 0; i++) {
+        if (field.documentation[i] === "(")
+            parenCount++;
+        if (field.documentation[i] === ")")
+            parenCount--;
+        if (parenCount === 0) {
+            endIdx = i;
+            break;
+        }
+    }
+    if (parenCount !== 0) {
+        return null;
+    }
+    const typeStr = field.documentation.substring(startIdx, endIdx).trim();
+    // Validate it's either a custom type or starts with Schema.
+    if (!(typeStr.startsWith("Schema.") || isCustomType(typeStr))) {
+        return null;
+    }
+    return typeStr;
+}
+/**
+ * Check if type string is a custom type reference
+ *
+ * Custom types are PascalCase identifiers without dots:
+ * - Valid: Vector1536, JSONBType, CustomEnum
+ * - Invalid: Schema.String, some.nested.type
+ *
+ * @param typeStr - Type string to check
+ * @returns true if it's a custom type reference
+ */
+function isCustomType(typeStr) {
+    return /^[A-Z][A-Za-z0-9]*$/.test(typeStr);
+}
+/**
+ * Check if field has any custom type annotations
+ *
+ * @param fields - Array of Prisma fields
+ * @returns true if any field uses custom types in @effectType
+ */
+export function hasCustomTypeAnnotations(fields) {
+    return fields.some((field) => {
+        const override = extractEffectTypeOverride(field);
+        return override && isCustomType(override);
+    });
+}

package/dist/src/schema-generator/utils/codegen.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Code generation utilities
+ */
+/**
+ * Generate standard file header for generated files
+ *
+ * @param timestamp - Optional timestamp (defaults to current time)
+ */
+export declare function generateFileHeader(timestamp?: Date): string;

package/dist/src/schema-generator/utils/codegen.js

@@ -0,0 +1,14 @@
+/**
+ * Code generation utilities
+ */
+/**
+ * Generate standard file header for generated files
+ *
+ * @param timestamp - Optional timestamp (defaults to current time)
+ */
+export function generateFileHeader(timestamp = new Date()) {
+    return `/**
+ * Generated: ${timestamp.toISOString()}
+ * DO NOT EDIT MANUALLY
+ */`;
+}

package/dist/src/schema-generator/utils/naming.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Naming utilities for consistent TypeScript identifier generation
+ */
+/**
+ * Convert any string to PascalCase with optional suffix
+ * Handles: snake_case, camelCase, kebab-case, or mixed formats
+ *
+ * @param str - The string to convert
+ * @param suffix - Optional suffix to append (e.g., "Schema", "Type")
+ *
+ * @example
+ * toPascalCase('user') // 'User'
+ * toPascalCase('PRODUCT_STATUS') // 'ProductStatus'
+ * toPascalCase('PRODUCT_STATUS', 'Schema') // 'ProductStatusSchema'
+ * toPascalCase('USER_ROLE', 'Type') // 'UserRoleType'
+ */
+export declare function toPascalCase(str: string, suffix?: string): string;
+/**
+ * Convert PascalCase or camelCase string to snake_case
+ * Used for generating database column names from model names
+ *
+ * @param str - The string to convert
+ *
+ * @example
+ * toSnakeCase('User') // 'user'
+ * toSnakeCase('ProductTag') // 'product_tag'
+ * toSnakeCase('ProductStatus') // 'product_status'
+ */
+export declare function toSnakeCase(str: string): string;

package/dist/src/schema-generator/utils/naming.js

@@ -0,0 +1,68 @@
+/**
+ * Naming utilities for consistent TypeScript identifier generation
+ */
+/**
+ * Convert any string to PascalCase with optional suffix
+ * Handles: snake_case, camelCase, kebab-case, or mixed formats
+ *
+ * @param str - The string to convert
+ * @param suffix - Optional suffix to append (e.g., "Schema", "Type")
+ *
+ * @example
+ * toPascalCase('user') // 'User'
+ * toPascalCase('PRODUCT_STATUS') // 'ProductStatus'
+ * toPascalCase('PRODUCT_STATUS', 'Schema') // 'ProductStatusSchema'
+ * toPascalCase('USER_ROLE', 'Type') // 'UserRoleType'
+ */
+export function toPascalCase(str, suffix) {
+    // Handle empty string
+    if (!str)
+        return str;
+    // Split on underscores, dashes, or spaces
+    const words = str.split(/[_-\s]+/);
+    let pascalCase;
+    // If no delimiters found, check if already camelCase/PascalCase
+    if (words.length === 1) {
+        // Split camelCase/PascalCase by capital letters
+        const camelWords = str.split(/(?=[A-Z])/);
+        if (camelWords.length > 1) {
+            pascalCase = camelWords
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join("");
+        }
+        else {
+            // Single word - just capitalize first letter
+            pascalCase = str.charAt(0).toUpperCase() + str.slice(1);
+        }
+    }
+    else {
+        // Convert each word to PascalCase
+        pascalCase = words
+            .filter((word) => word.length > 0) // Remove empty strings
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join("");
+    }
+    return suffix ? `${pascalCase}${suffix}` : pascalCase;
+}
+/**
+ * Convert PascalCase or camelCase string to snake_case
+ * Used for generating database column names from model names
+ *
+ * @param str - The string to convert
+ *
+ * @example
+ * toSnakeCase('User') // 'user'
+ * toSnakeCase('ProductTag') // 'product_tag'
+ * toSnakeCase('ProductStatus') // 'product_status'
+ */
+export function toSnakeCase(str) {
+    if (!str)
+        return str;
+    return (str
+        // Insert underscore before uppercase letters (except at start)
+        .replace(/([A-Z])/g, "_$1")
+        // Remove leading underscore if present
+        .replace(/^_/, "")
+        // Convert to lowercase
+        .toLowerCase());
+}

package/dist/src/schema-generator/utils/type-mappings.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Centralized Prisma type mappings
+ *
+ * Single source of truth for mapping Prisma scalar types to:
+ * - Effect Schema types (for schema generation)
+ * - TypeScript types (for Kysely interfaces)
+ *
+ * This eliminates duplication across effect/type.ts, kysely/type.ts, and effect/join-table.ts
+ */
+/**
+ * Prisma scalar type mapping to Effect Schema types
+ * Uses const assertion for type safety
+ *
+ * Note: DateTime uses Schema.DateFromSelf (not Schema.Date) so that:
+ * - Type = Date (runtime)
+ * - Encoded = Date (database)
+ * This allows Kysely to work with native Date objects directly.
+ * Schema.Date would encode to string, requiring ISO string conversions.
+ */
+export declare const PRISMA_TO_EFFECT_SCHEMA: {
+    readonly String: "Schema.String";
+    readonly Int: "Schema.Number";
+    readonly Float: "Schema.Number";
+    readonly BigInt: "Schema.BigInt";
+    readonly Decimal: "Schema.String";
+    readonly Boolean: "Schema.Boolean";
+    readonly DateTime: "Schema.DateFromSelf";
+    readonly Json: "Schema.Unknown";
+    readonly Bytes: "Schema.Uint8Array";
+};
+/**
+ * Prisma scalar type mapping to TypeScript types (for Kysely interfaces)
+ */
+export declare const PRISMA_TO_TYPESCRIPT: {
+    readonly String: "string";
+    readonly Int: "number";
+    readonly Float: "number";
+    readonly Boolean: "boolean";
+    readonly DateTime: "Date";
+    readonly Json: "unknown";
+    readonly Bytes: "Buffer";
+    readonly Decimal: "string";
+    readonly BigInt: "string";
+};
+/**
+ * Type-safe key type for Prisma scalar types
+ */
+export type PrismaScalarType = keyof typeof PRISMA_TO_EFFECT_SCHEMA;
+/**
+ * Type guard to check if a string is a valid Prisma scalar type
+ */
+export declare function isPrismaScalarType(type: string): type is PrismaScalarType;
+/**
+ * Get Effect Schema type for a Prisma scalar type
+ * Returns undefined for non-scalar types (enums, relations)
+ */
+export declare function getEffectSchemaType(type: string): "Schema.String" | "Schema.Number" | "Schema.BigInt" | "Schema.Boolean" | "Schema.DateFromSelf" | "Schema.Unknown" | "Schema.Uint8Array" | undefined;
+/**
+ * Get TypeScript type for a Prisma scalar type
+ * Returns the input type unchanged for non-scalar types (enums, models)
+ */
+export declare function getTypeScriptType(type: string): string;

package/dist/src/schema-generator/utils/type-mappings.js

@@ -0,0 +1,70 @@
+/**
+ * Centralized Prisma type mappings
+ *
+ * Single source of truth for mapping Prisma scalar types to:
+ * - Effect Schema types (for schema generation)
+ * - TypeScript types (for Kysely interfaces)
+ *
+ * This eliminates duplication across effect/type.ts, kysely/type.ts, and effect/join-table.ts
+ */
+/**
+ * Prisma scalar type mapping to Effect Schema types
+ * Uses const assertion for type safety
+ *
+ * Note: DateTime uses Schema.DateFromSelf (not Schema.Date) so that:
+ * - Type = Date (runtime)
+ * - Encoded = Date (database)
+ * This allows Kysely to work with native Date objects directly.
+ * Schema.Date would encode to string, requiring ISO string conversions.
+ */
+export const PRISMA_TO_EFFECT_SCHEMA = {
+    String: "Schema.String",
+    Int: "Schema.Number",
+    Float: "Schema.Number",
+    BigInt: "Schema.BigInt",
+    Decimal: "Schema.String", // For precision
+    Boolean: "Schema.Boolean",
+    DateTime: "Schema.DateFromSelf", // Native Date type for Kysely compatibility
+    Json: "Schema.Unknown", // Safe unknown type
+    Bytes: "Schema.Uint8Array",
+};
+/**
+ * Prisma scalar type mapping to TypeScript types (for Kysely interfaces)
+ */
+export const PRISMA_TO_TYPESCRIPT = {
+    String: "string",
+    Int: "number",
+    Float: "number",
+    Boolean: "boolean",
+    DateTime: "Date",
+    Json: "unknown",
+    Bytes: "Buffer",
+    Decimal: "string",
+    BigInt: "string", // Kysely convention
+};
+/**
+ * Type guard to check if a string is a valid Prisma scalar type
+ */
+export function isPrismaScalarType(type) {
+    return type in PRISMA_TO_EFFECT_SCHEMA;
+}
+/**
+ * Get Effect Schema type for a Prisma scalar type
+ * Returns undefined for non-scalar types (enums, relations)
+ */
+export function getEffectSchemaType(type) {
+    if (isPrismaScalarType(type)) {
+        return PRISMA_TO_EFFECT_SCHEMA[type];
+    }
+    return undefined;
+}
+/**
+ * Get TypeScript type for a Prisma scalar type
+ * Returns the input type unchanged for non-scalar types (enums, models)
+ */
+export function getTypeScriptType(type) {
+    if (isPrismaScalarType(type)) {
+        return PRISMA_TO_TYPESCRIPT[type];
+    }
+    return type;
+}

package/dist/src/services/formatter-service.d.ts

@@ -0,0 +1,10 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+declare const FormatterService_base: Context.TagClass<FormatterService, "FormatterService", {
+    readonly format: (code: string) => Effect.Effect<string, Error>;
+}>;
+export declare class FormatterService extends FormatterService_base {
+    static Live: Layer.Layer<FormatterService, never, never>;
+}
+export {};

package/dist/src/services/formatter-service.js

@@ -0,0 +1,18 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { createFromBuffer } from "@dprint/formatter";
+import { getPath } from "@dprint/typescript";
+import * as fs from "node:fs";
+export class FormatterService extends Context.Tag("FormatterService")() {
+    static Live = Layer.sync(FormatterService, () => {
+        const buffer = fs.readFileSync(getPath());
+        const formatter = createFromBuffer(buffer);
+        return {
+            format: (code) => Effect.try({
+                try: () => formatter.formatText({ filePath: "file.ts", fileText: code }),
+                catch: (error) => new Error(`Failed to format code: ${error}`),
+            }),
+        };
+    });
+}

package/dist/src/services/generator-context.d.ts

@@ -1,5 +1,5 @@
-import type { GeneratorOptions } from '@prisma/generator-helper';
-import * as Context from 'effect/Context';
+import type { GeneratorOptions } from "@prisma/generator-helper";
+import * as Context from "effect/Context";
 declare const GeneratorContext_base: Context.TagClass<GeneratorContext, "GeneratorContext", GeneratorOptions>;
 export declare class GeneratorContext extends GeneratorContext_base {
 }

package/dist/src/services/generator-context.js

@@ -1,3 +1,3 @@
-import * as Context from 'effect/Context';
-export class GeneratorContext extends Context.Tag('GeneratorContext')() {
+import * as Context from "effect/Context";
+export class GeneratorContext extends Context.Tag("GeneratorContext")() {
 }

package/dist/src/services/generator-service.d.ts

@@ -1,14 +1,15 @@
-import * as FileSystem from '@effect/platform/FileSystem';
-import * as Path from '@effect/platform/Path';
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import { GeneratorContext } from './generator-context.js';
-import { RenderService } from './render-service.js';
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { GeneratorContext } from "./generator-context.js";
+import { RenderService } from "./render-service.js";
+import { FormatterService } from "./formatter-service.js";
 declare const GeneratorService_base: Context.TagClass<GeneratorService, "GeneratorService", {
     readonly generate: Effect.Effect<void, Error, GeneratorContext>;
 }>;
 export declare class GeneratorService extends GeneratorService_base {
-    static Live: Layer.Layer<GeneratorService, never, FileSystem.FileSystem | Path.Path | RenderService>;
+    static Live: Layer.Layer<GeneratorService, never, FileSystem.FileSystem | Path.Path | RenderService | FormatterService>;
 }
 export {};