@odata-effect/odata-effect-generator 0.3.1 → 0.4.0

package/src/digester/Digester.ts

@@ -6,7 +6,14 @@
  */
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import { getClassName, getPropertyName } from "../generator/NamingHelper.js"
+import {
+  getClassName,
+  getClassNameWithOverrides,
+  getOperationNameWithOverrides,
+  getOperationParameterNameWithOverrides,
+  getPropertyNameWithOverrides
+} from "../generator/NamingHelper.js"
+import type { NamingOverrides } from "../model/GeneratorConfig.js"
 import {
   type ComplexTypeModel,
   createDataModel,
@@ -69,6 +76,7 @@ interface DigestContext {
   readonly enumTypes: Set<string>
   readonly complexTypes: Set<string>
   readonly entityTypes: Set<string>
+  readonly overrides?: NamingOverrides | undefined
 }
 
 /**
@@ -78,7 +86,8 @@ interface DigestContext {
  * @category digestion
  */
 export const digestMetadata = (
-  edmx: ODataEdmxModel
+  edmx: ODataEdmxModel,
+  overrides?: NamingOverrides
 ): Effect.Effect<DataModel, DigestError> =>
   Effect.try({
     try: () => {
@@ -107,7 +116,7 @@ export const digestMetadata = (
       const dataModel = createDataModel(version, namespace, serviceName)
 
       // Build context for type resolution
-      const context = buildContext(version, namespace, schemas)
+      const context = buildContext(version, namespace, schemas, overrides)
 
       // First pass: collect all type names
       for (const schema of schemas) {
@@ -139,7 +148,8 @@ export const digestMetadata = (
 const buildContext = (
   version: ODataVersion,
   namespace: string,
-  schemas: ReadonlyArray<EdmxSchema>
+  schemas: ReadonlyArray<EdmxSchema>,
+  overrides?: NamingOverrides
 ): DigestContext => {
   const associations = new Map<string, Association>()
 
@@ -159,7 +169,8 @@ const buildContext = (
     associations,
     enumTypes: new Set(),
     complexTypes: new Set(),
-    entityTypes: new Set()
+    entityTypes: new Set(),
+    overrides
   }
 }
 
@@ -265,14 +276,18 @@ const digestComplexType = (
   namespace: string,
   context: DigestContext
 ): ComplexTypeModel => {
-  const name = complexType.$.Name
-  const properties = (complexType.Property ?? []).map((p) => digestProperty(p, [], context))
-  const navigationProperties = (complexType.NavigationProperty ?? []).map((np) => digestNavigationProperty(np, context))
+  const odataTypeName = complexType.$.Name
+  const properties = (complexType.Property ?? []).map((p) =>
+    digestProperty(p, [], odataTypeName, "complex", context)
+  )
+  const navigationProperties = (complexType.NavigationProperty ?? []).map((np) =>
+    digestNavigationProperty(np, odataTypeName, "complex", context)
+  )
 
   const result: ComplexTypeModel = {
-    fqName: `${namespace}.${name}`,
-    odataName: name,
-    name: getClassName(name),
+    fqName: `${namespace}.${odataTypeName}`,
+    odataName: odataTypeName,
+    name: getClassNameWithOverrides(odataTypeName, "complex", context.overrides),
     properties,
     navigationProperties,
     isAbstract: complexType.$.Abstract === "true",
@@ -294,7 +309,7 @@ const digestEntityType = (
   namespace: string,
   context: DigestContext
 ): EntityTypeModel => {
-  const name = entityType.$.Name
+  const odataTypeName = entityType.$.Name
   const keyNames = new Set<string>()
 
   // Collect key property names
@@ -304,15 +319,19 @@ const digestEntityType = (
     }
   }
 
-  const properties = (entityType.Property ?? []).map((p) => digestProperty(p, Array.from(keyNames), context))
+  const properties = (entityType.Property ?? []).map((p) =>
+    digestProperty(p, Array.from(keyNames), odataTypeName, "entity", context)
+  )
 
   const keys = properties.filter((p) => p.isKey)
-  const navigationProperties = (entityType.NavigationProperty ?? []).map((np) => digestNavigationProperty(np, context))
+  const navigationProperties = (entityType.NavigationProperty ?? []).map((np) =>
+    digestNavigationProperty(np, odataTypeName, "entity", context)
+  )
 
   const result: EntityTypeModel = {
-    fqName: `${namespace}.${name}`,
-    odataName: name,
-    name: getClassName(name),
+    fqName: `${namespace}.${odataTypeName}`,
+    odataName: odataTypeName,
+    name: getClassNameWithOverrides(odataTypeName, "entity", context.overrides),
     keys,
     properties,
     navigationProperties,
@@ -333,6 +352,8 @@ const digestEntityType = (
 const digestProperty = (
   property: Property,
   keyNames: ReadonlyArray<string>,
+  ownerTypeName: string,
+  ownerTypeKind: "entity" | "complex",
   context: DigestContext
 ): PropertyModel => {
   const odataName = property.$.Name
@@ -345,7 +366,7 @@ const digestProperty = (
 
   const result: PropertyModel = {
     odataName,
-    name: getPropertyName(odataName),
+    name: getPropertyNameWithOverrides(odataName, ownerTypeName, ownerTypeKind, context.overrides),
     odataType,
     typeMapping,
     isCollection,
@@ -380,6 +401,8 @@ const isV4NavigationProperty = (
  */
 const digestNavigationProperty = (
   navProp: NavigationProperty,
+  ownerTypeName: string,
+  ownerTypeKind: "entity" | "complex",
   context: DigestContext
 ): NavigationPropertyModel => {
   const odataName = navProp.$.Name
@@ -391,7 +414,7 @@ const digestNavigationProperty = (
 
     const result: NavigationPropertyModel = {
       odataName,
-      name: getPropertyName(odataName),
+      name: getPropertyNameWithOverrides(odataName, ownerTypeName, ownerTypeKind, context.overrides),
       targetType: targetTypeName,
       isCollection,
       isNullable: navProp.$.Nullable !== "false"
@@ -423,7 +446,7 @@ const digestNavigationProperty = (
 
   return {
     odataName,
-    name: getPropertyName(odataName),
+    name: getPropertyNameWithOverrides(odataName, ownerTypeName, ownerTypeKind, context.overrides),
     targetType,
     isCollection,
     isNullable: true
@@ -467,10 +490,12 @@ const digestEntityContainer = (
     for (const funcImport of container.FunctionImport) {
       // Only process V2 function imports (no Function reference)
       if (!funcImport.$.Function) {
+        const odataOpName = funcImport.$.Name
         const params: Array<OperationParameterModel> = (funcImport.Parameter ?? []).map((p) => {
           const { baseType, isCollection } = parseODataType(p.$.Type)
           return {
-            name: getPropertyName(p.$.Name),
+            name: getOperationParameterNameWithOverrides(p.$.Name, odataOpName, context.overrides),
+            odataName: p.$.Name,
             odataType: p.$.Type,
             typeMapping: resolveTypeMapping(baseType, context),
             isNullable: p.$.Nullable !== "false",
@@ -479,9 +504,9 @@ const digestEntityContainer = (
         })
 
         let model: OperationModel = {
-          fqName: `${context.namespace}.${funcImport.$.Name}`,
-          odataName: funcImport.$.Name,
-          name: getPropertyName(funcImport.$.Name),
+          fqName: `${context.namespace}.${odataOpName}`,
+          odataName: odataOpName,
+          name: getOperationNameWithOverrides(odataOpName, context.overrides),
           type: "Function",
           isBound: false,
           parameters: params
@@ -519,13 +544,14 @@ const digestOperation = (
   type: "Function" | "Action",
   context: DigestContext
 ): OperationModel => {
-  const name = operation.$.Name
+  const odataName = operation.$.Name
   const isBound = operation.$.IsBound === "true"
 
   const allParams = (operation.Parameter ?? []).map((p) => {
     const { baseType, isCollection } = parseODataType(p.$.Type)
     return {
-      name: getPropertyName(p.$.Name),
+      name: getOperationParameterNameWithOverrides(p.$.Name, odataName, context.overrides),
+      odataName: p.$.Name,
       odataType: p.$.Type,
       typeMapping: resolveTypeMapping(baseType, context),
       isNullable: p.$.Nullable !== "false",
@@ -538,9 +564,9 @@ const digestOperation = (
   const parameters = isBound ? allParams.slice(1) : allParams
 
   let model: OperationModel = {
-    fqName: `${namespace}.${name}`,
-    odataName: name,
-    name: getPropertyName(name),
+    fqName: `${namespace}.${odataName}`,
+    odataName,
+    name: getOperationNameWithOverrides(odataName, context.overrides),
     type,
     isBound,
     parameters

package/src/generator/Generator.ts

@@ -8,6 +8,7 @@ import * as Path from "@effect/platform/Path"
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import type { DataModel } from "../model/DataModel.js"
+import type { NamingOverrides } from "../model/GeneratorConfig.js"
 import { generateIndex } from "./IndexGenerator.js"
 import { generateModels } from "./ModelsGenerator.js"
 import { generateNavigations } from "./NavigationGenerator.js"
@@ -32,11 +33,13 @@ import { generateServiceFns } from "./ServiceFnGenerator.js"
  */
 export interface GeneratorConfig {
   readonly outputDir: string
-  readonly packageName?: string
-  readonly serviceName?: string
-  readonly force?: boolean
+  readonly packageName?: string | undefined
+  readonly serviceName?: string | undefined
+  readonly force?: boolean | undefined
   /** Generate only source files directly in outputDir (no package.json, tsconfig, src/ subdirectory) */
-  readonly filesOnly?: boolean
+  readonly filesOnly?: boolean | undefined
+  /** Optional naming overrides for properties and types */
+  readonly overrides?: NamingOverrides | undefined
 }
 
 /**

package/src/generator/ModelsGenerator.ts

@@ -291,7 +291,8 @@ const generateSchemaFields = (
     const prop = properties[i]
     const schemaType = getPropertySchemaType(prop, prop.isNullable && !prop.isKey)
     const isLast = i === properties.length - 1
-    fields.push(`${prop.name}: ${schemaType}${isLast ? "" : ","}`)
+    const fieldDef = getPropertyFieldDefinition(prop, schemaType)
+    fields.push(`${fieldDef}${isLast ? "" : ","}`)
   }
 
   // Navigation properties are intentionally excluded from Schema.Class
@@ -312,12 +313,40 @@ const generateEditableSchemaFields = (
     const prop = properties[i]
     const schemaType = getPropertySchemaType(prop, prop.isNullable)
     const isLast = i === properties.length - 1
-    fields.push(`${prop.name}: ${schemaType}${isLast ? "" : ","}`)
+    const fieldDef = getPropertyFieldDefinition(prop, schemaType)
+    fields.push(`${fieldDef}${isLast ? "" : ","}`)
   }
 
   return fields
 }
 
+/**
+ * Get a complete property field definition including fromKey mapping if needed.
+ *
+ * When the OData property name differs from the TypeScript property name,
+ * we use Schema.propertySignature with Schema.fromKey to map between them.
+ * This is essential for OData V2 responses which use PascalCase property names.
+ *
+ * @example
+ * // When odataName == name:
+ * name: Schema.String
+ *
+ * // When odataName ("ID") != name ("id"):
+ * id: Schema.propertySignature(Schema.Number).pipe(Schema.fromKey("ID"))
+ */
+const getPropertyFieldDefinition = (
+  prop: PropertyModel,
+  schemaType: string
+): string => {
+  // If OData name matches TypeScript name, use simple format
+  if (prop.odataName === prop.name) {
+    return `${prop.name}: ${schemaType}`
+  }
+
+  // Use propertySignature with fromKey to map between encoded (OData) and decoded (TypeScript) names
+  return `${prop.name}: Schema.propertySignature(${schemaType}).pipe(Schema.fromKey("${prop.odataName}"))`
+}
+
 /**
  * Get the Schema type for a property.
  */

package/src/generator/NamingHelper.ts

@@ -3,6 +3,13 @@
  *
  * @since 1.0.0
  */
+import {
+  getOperationOverride,
+  getOperationParameterOverride,
+  getPropertyOverride,
+  getTypeOverride,
+  type NamingOverrides
+} from "../model/GeneratorConfig.js"
 
 /**
  * Convert a string to PascalCase.
@@ -164,3 +171,111 @@ export const getEditableTypeName = (typeName: string): string => {
 export const getIdTypeName = (typeName: string): string => {
   return `${toPascalCase(typeName)}Id`
 }
+
+// ============================================================================
+// Override-aware naming functions
+// ============================================================================
+
+/**
+ * Get the TypeScript property name for an OData property, with override support.
+ *
+ * @param odataName - The original OData property name
+ * @param typeName - The OData type name this property belongs to
+ * @param typeKind - Whether the type is an entity or complex type
+ * @param overrides - Optional naming overrides configuration
+ * @returns The TypeScript property name
+ *
+ * @since 1.0.0
+ * @category naming
+ */
+export const getPropertyNameWithOverrides = (
+  odataName: string,
+  typeName: string,
+  typeKind: "entity" | "complex",
+  overrides?: NamingOverrides
+): string => {
+  // Check for override first
+  const override = getPropertyOverride(overrides, typeName, typeKind, odataName)
+  if (override) {
+    return override
+  }
+
+  // Fall back to default camelCase conversion
+  return getPropertyName(odataName)
+}
+
+/**
+ * Get the TypeScript class name for an OData type, with override support.
+ *
+ * @param odataName - The original OData type name
+ * @param typeKind - Whether the type is an entity or complex type
+ * @param overrides - Optional naming overrides configuration
+ * @returns The TypeScript class name
+ *
+ * @since 1.0.0
+ * @category naming
+ */
+export const getClassNameWithOverrides = (
+  odataName: string,
+  typeKind: "entity" | "complex",
+  overrides?: NamingOverrides
+): string => {
+  // Check for override first
+  const override = getTypeOverride(overrides, odataName, typeKind)
+  if (override) {
+    return override
+  }
+
+  // Fall back to default PascalCase conversion
+  return getClassName(odataName)
+}
+
+/**
+ * Get the TypeScript function name for an OData operation, with override support.
+ *
+ * @param odataName - The original OData operation name
+ * @param overrides - Optional naming overrides configuration
+ * @returns The TypeScript function name (camelCase)
+ *
+ * @since 1.0.0
+ * @category naming
+ */
+export const getOperationNameWithOverrides = (
+  odataName: string,
+  overrides?: NamingOverrides
+): string => {
+  // Check for override first
+  const override = getOperationOverride(overrides, odataName)
+  if (override) {
+    return override
+  }
+
+  // Fall back to default camelCase conversion
+  return getPropertyName(odataName)
+}
+
+/**
+ * Get the TypeScript parameter name for an OData operation parameter, with override support.
+ *
+ * @param odataParamName - The original OData parameter name
+ * @param odataOperationName - The OData operation this parameter belongs to
+ * @param overrides - Optional naming overrides configuration
+ * @returns The TypeScript parameter name (camelCase)
+ *
+ * @since 1.0.0
+ * @category naming
+ */
+export const getOperationParameterNameWithOverrides = (
+  odataParamName: string,
+  odataOperationName: string,
+  overrides?: NamingOverrides
+): string => {
+  // Check for override first
+  const override = getOperationParameterOverride(overrides, odataOperationName, odataParamName)
+  if (override) {
+    return override
+  }
+
+  // Fall back to default camelCase conversion
+  return getPropertyName(odataParamName)
+}

package/src/generator/OperationsGenerator.ts

@@ -6,9 +6,9 @@
  *
  * @since 1.0.0
  */
-import type { DataModel, OperationModel } from "../model/DataModel.js"
+import type { DataModel, OperationModel, OperationParameterModel } from "../model/DataModel.js"
 import type { ODataVersion } from "../parser/EdmxSchema.js"
-import { toCamelCase, toPascalCase } from "./NamingHelper.js"
+import { toPascalCase } from "./NamingHelper.js"
 
 /**
  * Version-specific imports and identifiers.
@@ -22,25 +22,26 @@ interface VersionConfig {
 const V2_CONFIG: VersionConfig = {
   clientConfigTag: "ODataClientConfig",
   clientConfigImport: "ODataClientConfig",
-  clientModule: "ODataClient"
+  clientModule: "OData"
 }
 
 const V4_CONFIG: VersionConfig = {
   clientConfigTag: "ODataV4ClientConfig",
   clientConfigImport: "ODataV4ClientConfig",
-  clientModule: "ODataV4Client"
+  clientModule: "ODataV4"
 }
 
 const getVersionConfig = (version: ODataVersion): VersionConfig => version === "V4" ? V4_CONFIG : V2_CONFIG
 
 /**
  * Get the function name for an operation.
+ * Note: operation.name is already properly cased by the Digester.
  *
  * @since 1.0.0
  * @category naming
  */
 export const getOperationFunctionName = (operation: OperationModel): string => {
-  return toCamelCase(operation.name)
+  return operation.name
 }
 
 /**
@@ -274,7 +275,7 @@ const generateParameterType = (
 ): string | null => {
   if (operation.parameters.length === 0) return null
 
-  const typeName = `${toPascalCase(operation.name)}Params`
+  const typeName = `${toPascalCase(operation.odataName)}Params`
   return typeName
 }
 
@@ -287,7 +288,7 @@ const generateParameterInterface = (
 ): void => {
   if (operation.parameters.length === 0) return
 
-  const typeName = `${toPascalCase(operation.name)}Params`
+  const typeName = `${toPascalCase(operation.odataName)}Params`
 
   lines.push(`/**`)
   lines.push(` * Parameters for ${operation.odataName} operation.`)
@@ -309,6 +310,26 @@ const generateParameterInterface = (
   lines.push(``)
 }
 
+/**
+ * Build the parameters object mapping TypeScript names to OData names.
+ */
+const generateParametersObject = (
+  lines: Array<string>,
+  params: ReadonlyArray<OperationParameterModel>,
+  indent: string
+): void => {
+  lines.push(`${indent}const parameters: ODataOps.OperationParameters = {`)
+  for (const param of params) {
+    // Map TypeScript param name to OData param name
+    if (param.name === param.odataName) {
+      lines.push(`${indent}  ${param.name}: params.${param.name},`)
+    } else {
+      lines.push(`${indent}  "${param.odataName}": params.${param.name},`)
+    }
+  }
+  lines.push(`${indent}}`)
+}
+
 /**
  * Generate V2 FunctionImport function.
  */
@@ -352,11 +373,7 @@ const generateV2FunctionImport = (
 
   // Build parameters object for the function import URL
   if (paramsType) {
-    lines.push(`    const parameters: ODataOps.OperationParameters = {`)
-    for (const param of operation.parameters) {
-      lines.push(`      ${param.name}: params.${param.name},`)
-    }
-    lines.push(`    }`)
+    generateParametersObject(lines, operation.parameters, "    ")
     lines.push(``)
   }
 
@@ -438,11 +455,7 @@ const generateV4Operation = (
   if (!isAction) {
     // V4 Functions use GET with parameters in URL
     if (paramsType) {
-      lines.push(`    const parameters: ODataOps.OperationParameters = {`)
-      for (const param of operation.parameters) {
-        lines.push(`      ${param.name}: params.${param.name},`)
-      }
-      lines.push(`    }`)
+      generateParametersObject(lines, operation.parameters, "    ")
       lines.push(`    const url = ODataOps.buildV4FunctionUrl("${operation.odataName}", parameters)`)
     } else {
       lines.push(`    const url = ODataOps.buildV4FunctionUrl("${operation.odataName}")`)
@@ -477,7 +490,27 @@ const generateV4Operation = (
     lines.push(`    const url = "${operation.odataName}"`)
     lines.push(``)
 
-    const bodyArg = paramsType ? "params" : "undefined"
+    // Build body with OData parameter names
+    let bodyArg = "undefined"
+    if (paramsType) {
+      // Check if any parameter names differ
+      const hasDifferentNames = operation.parameters.some((p) => p.name !== p.odataName)
+      if (hasDifferentNames) {
+        lines.push(`    const body = {`)
+        for (const param of operation.parameters) {
+          if (param.name === param.odataName) {
+            lines.push(`      ${param.name}: params.${param.name},`)
+          } else {
+            lines.push(`      "${param.odataName}": params.${param.name},`)
+          }
+        }
+        lines.push(`    }`)
+        lines.push(``)
+        bodyArg = "body"
+      } else {
+        bodyArg = "params"
+      }
+    }
 
     if (!operation.returnType) {
       lines.push(`    return yield* ODataOps.executeV4ActionVoid(client, config, url, ${bodyArg})`)

package/src/index.ts

@@ -55,6 +55,41 @@ export * as ModelsGenerator from "./generator/ModelsGenerator.js"
  */
 export * as NamingHelper from "./generator/NamingHelper.js"
 
+/**
+ * Generator for type-safe, tree-shakable navigation path builders.
+ *
+ * Generates branded path types and navigation functions that can be composed
+ * with pipe() for type-safe OData path construction.
+ *
+ * @example
+ * ```typescript
+ * import { pipe } from "effect"
+ * import { People, byKey, trips, planItems, asFlight } from "./PathBuilders"
+ *
+ * const path = pipe(
+ *   People,
+ *   byKey("russellwhyte"),
+ *   trips,
+ *   byKey(0),
+ *   planItems,
+ *   asFlight
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ */
+export * as NavigationGenerator from "./generator/NavigationGenerator.js"
+
+/**
+ * Generator for OData operations (FunctionImports, Functions, Actions).
+ *
+ * OData V2: FunctionImports
+ * OData V4: Functions (GET, no side effects) and Actions (POST, with side effects)
+ *
+ * @since 1.0.0
+ */
+export * as OperationsGenerator from "./generator/OperationsGenerator.js"
+
 /**
  * Generator for package configuration files.
  *
@@ -70,33 +105,29 @@ export * as PackageGenerator from "./generator/PackageGenerator.js"
 export * as QueryModelsGenerator from "./generator/QueryModelsGenerator.js"
 
 /**
- * Generator for tree-shakable service functions.
+ * Generator for entity services using the crud factory.
  *
- * This module generates standalone functions that can be tree-shaken.
- * Each entity service is a module of standalone functions that use
- * the tree-shakable OData functions directly.
+ * This module generates a single Services.ts file that creates CRUD services
+ * for all entity sets using the crud factory from @odata-effect/odata-effect.
  *
  * @since 1.0.0
  */
 export * as ServiceFnGenerator from "./generator/ServiceFnGenerator.js"
 
 /**
- * Generator for tree-shakable navigation path builders.
- *
- * This module generates pipe-based navigation functions and the toPromise
- * helper for Promise-based environments.
+ * Intermediate representation for OData metadata.
+ * This is the central data model that digesters create and generators consume.
  *
  * @since 1.0.0
  */
-export * as NavigationGenerator from "./generator/NavigationGenerator.js"
+export * as DataModel from "./model/DataModel.js"
 
 /**
- * Intermediate representation for OData metadata.
- * This is the central data model that digesters create and generators consume.
+ * Configuration for code generation including name overrides.
  *
  * @since 1.0.0
  */
-export * as DataModel from "./model/DataModel.js"
+export * as GeneratorConfig from "./model/GeneratorConfig.js"
 
 /**
  * Common EDMX schema interfaces for OData metadata parsing.

package/src/model/DataModel.ts

@@ -197,6 +197,7 @@ export interface SingletonModel {
  * @category model
  */
 export interface OperationParameterModel {
+  readonly odataName: string
   readonly name: string
   readonly odataType: string
   readonly typeMapping: TypeMapping