@odata-effect/odata-effect-generator 0.1.0

package/src/digester/TypeMapper.ts

@@ -0,0 +1,181 @@
+/**
+ * Type mapper for converting OData types to Effect Schema types and query paths.
+ *
+ * @since 1.0.0
+ */
+import type { TypeMapping } from "../model/DataModel.js"
+import type { ODataVersion } from "../parser/EdmxSchema.js"
+
+// ============================================================================
+// Type Mappings
+// ============================================================================
+
+/**
+ * Default type mapping for unknown types.
+ */
+const UNKNOWN_TYPE: TypeMapping = {
+  effectSchema: "Schema.Unknown",
+  queryPath: "StringPath",
+  tsType: "unknown"
+}
+
+/**
+ * OData V2 type mappings.
+ */
+const V2_TYPE_MAP: Record<string, TypeMapping> = {
+  "Edm.String": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.Boolean": { effectSchema: "Schema.Boolean", queryPath: "BooleanPath", tsType: "boolean" },
+  "Edm.Byte": { effectSchema: "Schema.Number", queryPath: "NumberPath", tsType: "number" },
+  "Edm.SByte": { effectSchema: "Schema.Number", queryPath: "NumberPath", tsType: "number" },
+  "Edm.Int16": { effectSchema: "Schema.Number", queryPath: "NumberPath", tsType: "number" },
+  "Edm.Int32": { effectSchema: "Schema.Number", queryPath: "NumberPath", tsType: "number" },
+  "Edm.Int64": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.Single": { effectSchema: "Schema.Number", queryPath: "NumberPath", tsType: "number" },
+  "Edm.Double": { effectSchema: "Schema.Number", queryPath: "NumberPath", tsType: "number" },
+  "Edm.Decimal": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.Guid": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.Time": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.DateTime": { effectSchema: "Schema.Date", queryPath: "DateTimePath", tsType: "Date" },
+  "Edm.DateTimeOffset": { effectSchema: "Schema.Date", queryPath: "DateTimePath", tsType: "Date" },
+  "Edm.Binary": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" }
+}
+
+/**
+ * OData V4 type mappings (extends V2).
+ */
+const V4_TYPE_MAP: Record<string, TypeMapping> = {
+  ...V2_TYPE_MAP,
+  "Edm.Date": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.TimeOfDay": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.Duration": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.Stream": { effectSchema: "Schema.String", queryPath: "StringPath", tsType: "string" },
+  "Edm.GeographyPoint": { effectSchema: "Schema.Unknown", queryPath: "StringPath", tsType: "unknown" },
+  "Edm.GeographyLineString": { effectSchema: "Schema.Unknown", queryPath: "StringPath", tsType: "unknown" },
+  "Edm.GeographyPolygon": { effectSchema: "Schema.Unknown", queryPath: "StringPath", tsType: "unknown" },
+  "Edm.GeometryPoint": { effectSchema: "Schema.Unknown", queryPath: "StringPath", tsType: "unknown" },
+  "Edm.GeometryLineString": { effectSchema: "Schema.Unknown", queryPath: "StringPath", tsType: "unknown" },
+  "Edm.GeometryPolygon": { effectSchema: "Schema.Unknown", queryPath: "StringPath", tsType: "unknown" }
+}
+
+// ============================================================================
+// Type Mapper
+// ============================================================================
+
+/**
+ * Parsed OData type information.
+ */
+export interface ParsedType {
+  readonly baseType: string
+  readonly isCollection: boolean
+}
+
+/**
+ * Parse an OData type string to extract base type and collection info.
+ *
+ * @example
+ * parseODataType("Edm.String") // { baseType: "Edm.String", isCollection: false }
+ * parseODataType("Collection(Edm.String)") // { baseType: "Edm.String", isCollection: true }
+ *
+ * @since 1.0.0
+ * @category parsing
+ */
+export const parseODataType = (typeString: string): ParsedType => {
+  const collectionMatch = typeString.match(/^Collection\((.+)\)$/)
+  if (collectionMatch) {
+    return {
+      baseType: collectionMatch[1],
+      isCollection: true
+    }
+  }
+  return {
+    baseType: typeString,
+    isCollection: false
+  }
+}
+
+/**
+ * Check if a type is a primitive EDM type.
+ *
+ * @since 1.0.0
+ * @category type-checking
+ */
+export const isPrimitiveType = (type: string): boolean => {
+  return type.startsWith("Edm.")
+}
+
+/**
+ * Get the type mapping for a primitive OData type.
+ *
+ * @since 1.0.0
+ * @category type-mapping
+ */
+export const getPrimitiveTypeMapping = (
+  version: ODataVersion,
+  type: string
+): TypeMapping => {
+  const typeMap = version === "V2" ? V2_TYPE_MAP : V4_TYPE_MAP
+  return typeMap[type] ?? UNKNOWN_TYPE
+}
+
+/**
+ * Create a type mapping for a complex type reference.
+ *
+ * @since 1.0.0
+ * @category type-mapping
+ */
+export const getComplexTypeMapping = (typeName: string): TypeMapping => ({
+  effectSchema: typeName,
+  queryPath: `EntityPath<Q${typeName}>`,
+  tsType: typeName
+})
+
+/**
+ * Create a type mapping for an enum type reference.
+ *
+ * @since 1.0.0
+ * @category type-mapping
+ */
+export const getEnumTypeMapping = (typeName: string): TypeMapping => ({
+  effectSchema: typeName,
+  queryPath: "StringPath",
+  tsType: typeName
+})
+
+/**
+ * Create a type mapping for a navigation property (single entity).
+ *
+ * @since 1.0.0
+ * @category type-mapping
+ */
+export const getNavigationTypeMapping = (typeName: string): TypeMapping => ({
+  effectSchema: `Schema.optional(${typeName})`,
+  queryPath: `EntityPath<Q${typeName}>`,
+  tsType: `${typeName} | undefined`
+})
+
+/**
+ * Create a type mapping for a navigation property (collection).
+ *
+ * @since 1.0.0
+ * @category type-mapping
+ */
+export const getCollectionNavigationTypeMapping = (typeName: string): TypeMapping => ({
+  effectSchema: `Schema.optional(Schema.Array(${typeName}))`,
+  queryPath: `CollectionPath<Q${typeName}>`,
+  tsType: `ReadonlyArray<${typeName}> | undefined`
+})
+
+/**
+ * Extract the simple type name from a fully qualified name.
+ *
+ * @example
+ * getSimpleTypeName("ODataDemo.Product") // "Product"
+ * getSimpleTypeName("Product") // "Product"
+ *
+ * @since 1.0.0
+ * @category naming
+ */
+export const getSimpleTypeName = (fqName: string): string => {
+  const parts = fqName.split(".")
+  return parts[parts.length - 1]
+}

package/src/generator/Generator.ts

@@ -0,0 +1,183 @@
+/**
+ * Main generator that orchestrates all code generation.
+ *
+ * @since 1.0.0
+ */
+import * as FileSystem from "@effect/platform/FileSystem"
+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 { generateIndex } from "./IndexGenerator.js"
+import { generateModels } from "./ModelsGenerator.js"
+import {
+  generatePackageJson,
+  generateTsconfig,
+  generateTsconfigBuild,
+  generateTsconfigSrc,
+  generateTsconfigTest,
+  generateVitestConfig,
+  type PackageConfig
+} from "./PackageGenerator.js"
+import { generateQueryModels } from "./QueryModelsGenerator.js"
+import { generateServiceFns } from "./ServiceFnGenerator.js"
+import { generatePromiseServiceFns } from "./ServiceFnPromiseGenerator.js"
+
+/**
+ * Generator configuration.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+export interface GeneratorConfig {
+  readonly outputDir: string
+  readonly packageName?: string
+  readonly serviceName?: string
+  readonly force?: boolean
+}
+
+/**
+ * Error thrown during code generation.
+ *
+ * @since 1.0.0
+ * @category errors
+ */
+export class GeneratorError extends Schema.TaggedError<GeneratorError>()(
+  "GeneratorError",
+  {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {}
+
+/**
+ * Generated file result.
+ */
+interface GeneratedFile {
+  readonly path: string
+  readonly content: string
+}
+
+/**
+ * Generate all code from a data model.
+ *
+ * @since 1.0.0
+ * @category generation
+ */
+export const generate = (
+  dataModel: DataModel,
+  config: GeneratorConfig
+): Effect.Effect<void, GeneratorError, FileSystem.FileSystem | Path.Path> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+
+    const outputDir = config.outputDir
+    const serviceName = config.serviceName ?? dataModel.serviceName
+    const packageName = config.packageName ?? `@template/${serviceName.toLowerCase()}-effect`
+
+    const packageConfig: PackageConfig = {
+      packageName,
+      serviceName
+    }
+
+    // Generate tree-shakable service function files
+    const serviceResult = generateServiceFns(dataModel)
+
+    // Generate Promise-based service function files
+    const promiseServiceResult = generatePromiseServiceFns(dataModel)
+
+    // Generate all files
+    const files: Array<GeneratedFile> = [
+      // Source files
+      {
+        path: path.join(outputDir, "src", "Models.ts"),
+        content: generateModels(dataModel)
+      },
+      {
+        path: path.join(outputDir, "src", "QueryModels.ts"),
+        content: generateQueryModels(dataModel)
+      },
+      // Individual entity service function files (tree-shakable)
+      ...serviceResult.entityServices.map((svc) => ({
+        path: path.join(outputDir, "src", svc.fileName),
+        content: svc.content
+      })),
+      // Promise-based entity service function files
+      ...promiseServiceResult.entityServices.map((svc) => ({
+        path: path.join(outputDir, "src", svc.fileName),
+        content: svc.content
+      })),
+      {
+        path: path.join(outputDir, "src", "index.ts"),
+        content: generateIndex(dataModel)
+      },
+      // Package configuration files
+      {
+        path: path.join(outputDir, "package.json"),
+        content: generatePackageJson(dataModel, packageConfig)
+      },
+      {
+        path: path.join(outputDir, "tsconfig.json"),
+        content: generateTsconfig()
+      },
+      {
+        path: path.join(outputDir, "tsconfig.src.json"),
+        content: generateTsconfigSrc()
+      },
+      {
+        path: path.join(outputDir, "tsconfig.test.json"),
+        content: generateTsconfigTest()
+      },
+      {
+        path: path.join(outputDir, "tsconfig.build.json"),
+        content: generateTsconfigBuild()
+      },
+      {
+        path: path.join(outputDir, "vitest.config.ts"),
+        content: generateVitestConfig()
+      }
+    ]
+
+    // Create output directories
+    yield* fs.makeDirectory(path.join(outputDir, "src"), { recursive: true }).pipe(
+      Effect.mapError((error) =>
+        new GeneratorError({
+          message: `Failed to create output directory: ${outputDir}/src`,
+          cause: error
+        })
+      )
+    )
+
+    // Write all files
+    for (const file of files) {
+      // Check if file exists and force is not set
+      if (!config.force) {
+        const exists = yield* fs.exists(file.path).pipe(
+          Effect.mapError(() =>
+            new GeneratorError({
+              message: `Failed to check file existence: ${file.path}`
+            })
+          )
+        )
+
+        if (exists) {
+          yield* Effect.logWarning(`Skipping existing file: ${file.path}`)
+          continue
+        }
+      }
+
+      yield* fs.writeFileString(file.path, file.content).pipe(
+        Effect.mapError((error) =>
+          new GeneratorError({
+            message: `Failed to write file: ${file.path}`,
+            cause: error
+          })
+        )
+      )
+
+      yield* Effect.logInfo(`Generated: ${file.path}`)
+    }
+
+    yield* Effect.logInfo(`Generation complete. Output: ${outputDir}`)
+  })

package/src/generator/IndexGenerator.ts

@@ -0,0 +1,189 @@
+/**
+ * Generator for index.ts - Public API exports.
+ *
+ * @since 1.0.0
+ */
+import type { DataModel } from "../model/DataModel.js"
+import {
+  getEditableTypeName,
+  getIdTypeName,
+  getQueryFactoryName,
+  getQueryInstanceName,
+  getQueryInterfaceName,
+  getServiceClassName
+} from "./NamingHelper.js"
+import { getPromiseServiceName } from "./ServiceFnPromiseGenerator.js"
+
+/**
+ * Generate the index.ts file content.
+ *
+ * @since 1.0.0
+ * @category generation
+ */
+export const generateIndex = (dataModel: DataModel): string => {
+  const lines: Array<string> = []
+
+  // Header
+  lines.push(`/**`)
+  lines.push(` * Effect-based OData client for ${dataModel.serviceName} service.`)
+  lines.push(` * Generated by odata-effect-gen.`)
+  lines.push(` *`)
+  lines.push(` * @since 1.0.0`)
+  lines.push(` */`)
+  lines.push(``)
+
+  // Models
+  lines.push(`// Models`)
+  lines.push(`export {`)
+
+  const modelExports: Array<string> = []
+
+  // Enums
+  for (const enumType of dataModel.enumTypes.values()) {
+    modelExports.push(enumType.name)
+  }
+
+  // Complex types
+  for (const complexType of dataModel.complexTypes.values()) {
+    modelExports.push(complexType.name)
+    modelExports.push(getEditableTypeName(complexType.name))
+  }
+
+  // Entity types
+  for (const entityType of dataModel.entityTypes.values()) {
+    modelExports.push(entityType.name)
+    if (entityType.keys.length > 0) {
+      modelExports.push(getIdTypeName(entityType.name))
+    }
+    modelExports.push(getEditableTypeName(entityType.name))
+  }
+
+  for (let i = 0; i < modelExports.length; i++) {
+    const isLast = i === modelExports.length - 1
+    lines.push(`  ${modelExports[i]}${isLast ? "" : ","}`)
+  }
+
+  lines.push(`} from "./Models.js"`)
+  lines.push(``)
+
+  // Re-export OData infrastructure
+  const isV4 = dataModel.version === "V4"
+  lines.push(`// Re-export OData infrastructure from @odata-effect/odata-effect`)
+  lines.push(`export {`)
+  lines.push(`  // Errors`)
+  if (!isV4) {
+    lines.push(`  SapErrorDetail,`)
+    lines.push(`  SapErrorResolution,`)
+    lines.push(`  SapApplication,`)
+    lines.push(`  SapInnerError,`)
+    lines.push(`  SapErrorMessage,`)
+    lines.push(`  SapErrorBody,`)
+    lines.push(`  SapErrorResponse,`)
+    lines.push(`  SapError,`)
+  }
+  lines.push(`  ODataError,`)
+  lines.push(`  EntityNotFoundError,`)
+  lines.push(`  ParseError,`)
+  if (isV4) {
+    // V4 exports
+    lines.push(`  // OData V4`)
+    lines.push(`  ODataV4,`)
+    lines.push(`  ODataV4CollectionResponse,`)
+    lines.push(`  ODataV4ValueResponse,`)
+    lines.push(`  ODataV4Annotations,`)
+    lines.push(`  ODataV4ClientConfig,`)
+    lines.push(`  buildEntityPathV4,`)
+    lines.push(`  type ODataV4QueryOptions,`)
+    lines.push(`  type ODataV4RequestOptions,`)
+    lines.push(`  type ODataV4ClientConfigService,`)
+    lines.push(`  type PagedResultV4,`)
+  } else {
+    // V2 exports
+    lines.push(`  // OData V2`)
+    lines.push(`  OData,`)
+    lines.push(`  ODataSingleResponse,`)
+    lines.push(`  ODataCollectionResponse,`)
+    lines.push(`  ODataCollectionResponseWithMeta,`)
+    lines.push(`  ODataValueResponse,`)
+    lines.push(`  EntityMetadata,`)
+    lines.push(`  MediaMetadata,`)
+    lines.push(`  DeferredContent,`)
+    lines.push(`  ODataClientConfig,`)
+    lines.push(`  buildEntityPath,`)
+    lines.push(`  DEFAULT_HEADERS,`)
+    lines.push(`  MERGE_HEADERS,`)
+    lines.push(`  type ODataQueryOptions,`)
+    lines.push(`  type ODataRequestOptions,`)
+    lines.push(`  type ODataClientConfigService,`)
+    lines.push(`  type PagedResult,`)
+  }
+  lines.push(`  // Query Builder`)
+  lines.push(`  FilterExpression,`)
+  lines.push(`  StringPath,`)
+  lines.push(`  NumberPath,`)
+  lines.push(`  BooleanPath,`)
+  lines.push(`  DateTimePath,`)
+  lines.push(`  EntityPath,`)
+  lines.push(`  CollectionPath,`)
+  lines.push(`  QueryBuilder,`)
+  lines.push(`  createQueryPaths,`)
+  lines.push(`  createQueryBuilder,`)
+  lines.push(`  type FieldToPath,`)
+  lines.push(`  type QueryPaths,`)
+  lines.push(`  type SelectableKeys,`)
+  lines.push(`  type ExpandableKeys,`)
+  lines.push(`  type BuiltQuery`)
+  lines.push(`} from "@odata-effect/odata-effect"`)
+  lines.push(``)
+
+  // Individual Entity Services (tree-shakable module namespace re-exports)
+  lines.push(`// Individual Entity Services (tree-shakable)`)
+  for (const entitySet of dataModel.entitySets.values()) {
+    const serviceClassName = getServiceClassName(entitySet.name)
+    lines.push(`export * as ${serviceClassName} from "./${serviceClassName}.js"`)
+  }
+  lines.push(``)
+
+  // Promise-based Entity Services (for non-Effect environments)
+  lines.push(`// Promise-based Entity Services (for non-Effect environments)`)
+  for (const entitySet of dataModel.entitySets.values()) {
+    const promiseServiceName = getPromiseServiceName(entitySet.name)
+    lines.push(`export * as ${promiseServiceName} from "./${promiseServiceName}.js"`)
+  }
+  lines.push(``)
+
+  // Query Models
+  lines.push(`// Query Models`)
+  lines.push(`export {`)
+
+  const queryExports: Array<string> = []
+
+  // Complex types
+  for (const complexType of dataModel.complexTypes.values()) {
+    queryExports.push(getQueryInstanceName(complexType.name))
+    queryExports.push(`type ${getQueryInterfaceName(complexType.name)}`)
+  }
+
+  // Entity types
+  for (const entityType of dataModel.entityTypes.values()) {
+    queryExports.push(getQueryInstanceName(entityType.name))
+    queryExports.push(`type ${getQueryInterfaceName(entityType.name)}`)
+  }
+
+  // Query factories for entity sets
+  for (const entitySet of dataModel.entitySets.values()) {
+    const entityType = dataModel.entityTypes.get(entitySet.entityTypeFqName)
+    if (entityType) {
+      queryExports.push(getQueryFactoryName(entityType.name))
+    }
+  }
+
+  for (let i = 0; i < queryExports.length; i++) {
+    const isLast = i === queryExports.length - 1
+    lines.push(`  ${queryExports[i]}${isLast ? "" : ","}`)
+  }
+
+  lines.push(`} from "./QueryModels.js"`)
+
+  return lines.join("\n")
+}