@abapify/openai-codegen 0.3.6 → 0.4.6

package/dist/index.d.mts

@@ -0,0 +1,496 @@
+import { i as resolveNames, n as NamesConfigError, r as ResolvedNames, t as NamesConfig } from "./naming-9hJCZKjv.mjs";
+import { BuiltinTypeName, ClassDef, Comment, InterfaceDef, Statement, TypeDef, TypeRef } from "@abapify/abap-ast";
+//#region src/oas/types.d.ts
+/**
+ * Narrowed OpenAPI 3.1-compatible types used by the code generator.
+ *
+ * These are deliberately decoupled from `openapi-types` to keep the surface
+ * small, stable, and friendly to ABAP emitters. `JsonSchema` is kept as an
+ * open record for now — later waves will refine it into a discriminated union
+ * when we need richer structural reasoning.
+ */
+type JsonSchema = Record<string, unknown>;
+interface JsonSchemaRef {
+  $ref: string;
+}
+declare function isRef(x: unknown): x is JsonSchemaRef;
+type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options' | 'trace';
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+interface SpecInfo {
+  title: string;
+  version: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: {
+    name?: string;
+    url?: string;
+    email?: string;
+  };
+  license?: {
+    name: string;
+    url?: string;
+    identifier?: string;
+  };
+}
+interface NormalizedServerVariable {
+  default: string;
+  enum?: string[];
+  description?: string;
+}
+interface NormalizedServer {
+  url: string;
+  description?: string;
+  variables: Record<string, NormalizedServerVariable>;
+}
+interface NormalizedParameter {
+  name: string;
+  in: ParameterLocation;
+  required: boolean;
+  schema: JsonSchema;
+  style?: string;
+  explode?: boolean;
+  description?: string;
+  deprecated: boolean;
+}
+interface NormalizedMediaType {
+  schema: JsonSchema;
+}
+interface NormalizedRequestBody {
+  required: boolean;
+  description?: string;
+  content: Record<string, NormalizedMediaType>;
+}
+interface NormalizedHeader {
+  schema: JsonSchema;
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+}
+interface NormalizedResponse {
+  statusCode: string;
+  isSuccess: boolean;
+  isError: boolean;
+  description?: string;
+  content: Record<string, NormalizedMediaType>;
+  headers: Record<string, NormalizedHeader>;
+}
+interface NormalizedOperation {
+  operationId: string;
+  method: HttpMethod;
+  path: string;
+  tags: string[];
+  summary?: string;
+  description?: string;
+  deprecated: boolean;
+  parameters: NormalizedParameter[];
+  requestBody?: NormalizedRequestBody;
+  responses: NormalizedResponse[];
+  security: SecurityRequirement[];
+}
+interface SecuritySchemeApiKey {
+  type: 'apiKey';
+  name: string;
+  in: 'header' | 'query' | 'cookie';
+  description?: string;
+}
+interface SecuritySchemeHttp {
+  type: 'http';
+  scheme: 'bearer' | 'basic' | string;
+  bearerFormat?: string;
+  description?: string;
+}
+interface OAuthFlow {
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  refreshUrl?: string;
+  scopes: Record<string, string>;
+}
+interface SecuritySchemeOAuth2 {
+  type: 'oauth2';
+  flows: {
+    implicit?: OAuthFlow;
+    password?: OAuthFlow;
+    clientCredentials?: OAuthFlow;
+    authorizationCode?: OAuthFlow;
+  };
+  description?: string;
+}
+interface SecuritySchemeOpenIdConnect {
+  type: 'openIdConnect';
+  openIdConnectUrl: string;
+  description?: string;
+}
+type SecurityScheme = SecuritySchemeApiKey | SecuritySchemeHttp | SecuritySchemeOAuth2 | SecuritySchemeOpenIdConnect;
+/** Map of scheme-name → required scopes. */
+type SecurityRequirement = Record<string, string[]>;
+interface NormalizedSpec {
+  openapiVersion: string;
+  info: SpecInfo;
+  servers: NormalizedServer[];
+  operations: NormalizedOperation[];
+  schemas: Record<string, JsonSchema>;
+  securitySchemes: Record<string, SecurityScheme>;
+}
+//#endregion
+//#region src/oas/load.d.ts
+/**
+ * Load and normalize an OpenAPI 3.x spec from a file path, URL, or in-memory
+ * object. YAML files (`.yaml` / `.yml`) are read manually with the `yaml`
+ * library first so we always hand SwaggerParser a parsed object — this keeps
+ * our behaviour identical for local files and in-memory inputs.
+ */
+declare function loadSpec(input: string | URL | object): Promise<NormalizedSpec>;
+/**
+ * Normalize a (presumed-dereferenced) OpenAPI document into our internal
+ * shape. Callers who already have a dereferenced spec may invoke this
+ * directly.
+ */
+declare function normalizeSpec(dereferenced: unknown, namedSchemas?: Record<string, JsonSchema>): NormalizedSpec;
+//#endregion
+//#region src/oas/iterate.d.ts
+interface SchemaVisit {
+  path: string[];
+  schema: JsonSchema;
+}
+type SchemaVisitor = (visit: SchemaVisit) => void;
+/**
+ * Depth-first walk over every distinct schema reachable from a normalized
+ * spec. Ordering is deterministic: components.schemas (by insertion order),
+ * then operations in spec order, with each operation yielding
+ * `parameters → requestBody → responses`. Inside each schema we descend into
+ * `properties`, `items`, `additionalProperties`, `allOf`/`anyOf`/`oneOf`, and
+ * `not`.
+ */
+declare function walkSchemas(spec: NormalizedSpec, cb: SchemaVisitor): void;
+/** Stable key used to identify an operation, e.g. `GET /pet/{petId}`. */
+declare function operationKey(op: NormalizedOperation): string;
+//#endregion
+//#region src/profiles/types.d.ts
+type TargetProfileId = 'on-prem-classic' | 's4-onprem-modern' | 's4-cloud';
+interface HttpClientStrategy {
+  kind: 'if_http_client' | 'if_web_http_client';
+  factoryClass: string;
+  destinationProviderClass?: string;
+}
+interface JsonStrategy {
+  kind: 'ui2_cl_json' | 'inline';
+  helperClass?: string;
+}
+interface TargetProfile {
+  id: TargetProfileId;
+  description: string;
+  http: HttpClientStrategy;
+  json: JsonStrategy;
+  /** Whitelist of system classes/interfaces the emitter may reference.
+   *  Uppercase, no leading 'if_'/'cl_' stripping. Tested case-insensitively. */
+  allowedClasses: ReadonlySet<string>;
+}
+//#endregion
+//#region src/profiles/errors.d.ts
+declare class WhitelistViolationError extends Error {
+  readonly className: string;
+  readonly profileId: string;
+  constructor(className: string, profileId: string);
+}
+//#endregion
+//#region src/profiles/cloud.d.ts
+declare const s4CloudProfile: TargetProfile;
+//#endregion
+//#region src/profiles/onprem-classic.d.ts
+declare const onPremClassicProfile: TargetProfile;
+//#endregion
+//#region src/profiles/onprem-modern.d.ts
+declare const s4OnPremModernProfile: TargetProfile;
+//#endregion
+//#region src/profiles/registry.d.ts
+declare const ALL_PROFILES: ReadonlyArray<TargetProfileId>;
+declare function getProfile(id: TargetProfileId): TargetProfile;
+declare function assertClassAllowed(profile: TargetProfile, className: string): void;
+//#endregion
+//#region src/types/naming.d.ts
+type IdentKind = 'type' | 'method' | 'param' | 'class';
+interface SanitizeOpts {
+  prefix?: string;
+  maxLen?: number;
+}
+/** Sanitize a raw identifier into an ABAP-safe name. */
+declare function sanitizeIdent(raw: string, kind: IdentKind, opts?: SanitizeOpts): string;
+type NameAllocator = (raw: string, kind: IdentKind, opts?: SanitizeOpts) => string;
+/** Create a collision-resolving allocator bound to a mutable name set. */
+declare function makeNameAllocator(usedNames: Set<string>): NameAllocator;
+//#endregion
+//#region src/types/plan.d.ts
+interface TypePlanEntry {
+  /** Stable logical id, e.g. "components.schemas.Pet" or "components.schemas.Pet.properties.x". */
+  readonly id: string;
+  /** ABAP type name (ty_foo). */
+  readonly abapName: string;
+  /** Original JSON schema object. */
+  readonly schema: JsonSchema;
+  /** Logical ids of other plan entries this one depends on. */
+  readonly dependencies: readonly string[];
+  /** Where the entry comes from. */
+  readonly source: 'component' | 'inline' | 'auxiliary';
+  /** True when the entry participates in a self-reference (directly or indirectly via itself). */
+  readonly selfReferential?: boolean;
+}
+interface TypePlan {
+  readonly entries: readonly TypePlanEntry[];
+  readonly byId: ReadonlyMap<string, TypePlanEntry>;
+}
+interface PlanTypesOptions {
+  /** ABAP prefix applied to every emitted type name, e.g. "zps3_" → ty names become ty_zps3_pet. We use it as-is, joined with snake name. */
+  typePrefix: string;
+}
+/** Plan the ABAP type universe for a normalized spec. */
+declare function planTypes(spec: NormalizedSpec, opts: PlanTypesOptions): TypePlan;
+//#endregion
+//#region src/types/map.d.ts
+/** Map a JSON Schema primitive (type+format) to an ABAP builtin type name. */
+declare function mapPrimitive(schema: JsonSchema): BuiltinTypeName;
+/** Resolve a schema to an ABAP TypeRef. */
+declare function mapSchemaToTypeRef(schema: JsonSchema, plan: TypePlan, ctx?: {
+  entryId?: string;
+}): TypeRef;
+/** Build a TypeDef node for a single plan entry. */
+declare function mapSchemaToTypeDef(entry: TypePlanEntry, plan: TypePlan): {
+  typeDef: TypeDef;
+  leadingComment?: Comment;
+};
+//#endregion
+//#region src/types/emit.d.ts
+/** Emit all TypeDef nodes for the given plan, in topological order. */
+declare function emitTypeSection(plan: TypePlan, _profile: TargetProfile): TypeDef[];
+//#endregion
+//#region src/types/errors.d.ts
+declare class CyclicTypeError extends Error {
+  constructor(message: string);
+}
+declare class CollisionError extends Error {
+  constructor(message: string);
+}
+declare class UnsupportedSchemaError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/emit/types-interface.d.ts
+interface EmitTypesInterfaceOptions {
+  /** UPPERCASE ABAP global interface name, e.g. 'ZIF_PETSTORE_TYPES'. */
+  readonly name: string;
+  /**
+   * When true, nullable fields (`nullable: true` or `type: [..., "null"]`)
+   * receive a sibling `<field>_is_null TYPE abap_bool` flag. Default false.
+   */
+  readonly emitNullFlags?: boolean;
+  /** Optional ABAPDoc header lines for the interface itself. */
+  readonly interfaceAbapDoc?: readonly string[];
+}
+interface EmitTypesInterfaceResult {
+  readonly interface: InterfaceDef;
+  readonly typeDefs: readonly TypeDef[];
+}
+/** Raised when polymorphism variants disagree on the type of a named field. */
+declare class PolymorphismConflictError extends Error {
+  constructor(message: string);
+}
+declare function emitTypesInterface(spec: NormalizedSpec, plan: TypePlan, opts: EmitTypesInterfaceOptions): EmitTypesInterfaceResult;
+//#endregion
+//#region src/emit/operations-interface.d.ts
+interface EmitOperationsInterfaceOptions {
+  /** Global interface name, e.g. 'ZIF_PETSTORE'. */
+  readonly name: string;
+  /** Name of the sibling types interface, e.g. 'ZIF_PETSTORE_TYPES'. */
+  readonly typesInterfaceName: string;
+  /** Name of the generated exception class, e.g. 'ZCX_PETSTORE_ERROR'. */
+  readonly exceptionClassName: string;
+  /** Optional ABAPDoc to attach to the interface itself. */
+  readonly interfaceAbapDoc?: readonly string[];
+}
+interface OperationParamMapping {
+  readonly name: string;
+  readonly openapiName: string;
+  readonly location: 'path' | 'query' | 'header';
+  readonly required: boolean;
+  readonly typeRefSource: string;
+  /** True when the ABAP type is a STANDARD TABLE (array) alias. */
+  readonly isTable: boolean;
+}
+interface OperationMapping {
+  readonly operationId: string;
+  readonly methodName: string;
+  readonly method: string;
+  readonly path: string;
+  readonly params: readonly OperationParamMapping[];
+  readonly hasBody: boolean;
+  readonly successStatus: number | 'default';
+  readonly successIsEmptyBody: boolean;
+  readonly errorResponses: Readonly<Record<string, {
+    description?: string;
+  }>>;
+  readonly returningName: string;
+}
+interface EmitOperationsInterfaceResult {
+  readonly interface: InterfaceDef;
+  readonly operations: readonly OperationMapping[];
+}
+declare function emitOperationsInterface(spec: NormalizedSpec, _plan: TypePlan, opts: EmitOperationsInterfaceOptions): EmitOperationsInterfaceResult;
+//#endregion
+//#region src/emit/exception-class.d.ts
+interface EmitExceptionClassOptions {
+  /** Global ABAP class name, e.g. `ZCX_PETSTORE_ERROR`. */
+  readonly name: string;
+  /** Optional class-level ABAPDoc lines. */
+  readonly interfaceAbapDoc?: readonly string[];
+}
+interface EmitExceptionClassResult {
+  readonly class: ClassDef;
+}
+declare function emitExceptionClass(opts: EmitExceptionClassOptions): EmitExceptionClassResult;
+//#endregion
+//#region src/emit/local-classes.d.ts
+interface LocalClassesBundle {
+  /** Content for <cls>.clas.locals_def.abap. */
+  localsDef: string;
+  /** Content for <cls>.clas.locals_imp.abap. */
+  localsImp: string;
+}
+declare function emitLocalClasses(names: ResolvedNames): LocalClassesBundle;
+//#endregion
+//#region src/emit/response-mapper.d.ts
+type SuccessBodyKind = {
+  kind: 'json';
+  returningName: string;
+} | {
+  kind: 'empty';
+  returningName: string;
+} | {
+  kind: 'binary';
+  returningName: string;
+};
+interface ResponseMapperOptions {
+  /** Fully-qualified ABAP exception class name. */
+  exceptionClassName: string;
+  /** Local class name used for JSON parsing (usually `json`). */
+  localJsonClassName: string;
+  /** Name of the local variable holding the fetch result. Default `response`. */
+  responseVarName?: string;
+  /** Determines how the 2xx / success branch is emitted. */
+  successBody: SuccessBodyKind;
+}
+interface ResponseMapperResult {
+  /** AST statement ready to append to a method body (wraps the CASE source). */
+  statement: Statement;
+  /** Raw ABAP source, formatted for insertion into a METHOD body. */
+  source: string;
+}
+declare function mapResponseHandling(operation: NormalizedOperation, opts: ResponseMapperOptions): ResponseMapperResult;
+//#endregion
+//#region src/format/types.d.ts
+/**
+ * Shared types for format plugins (abapGit / gCTS).
+ *
+ * A {@link ClassArtifact} is the abstract, format-agnostic description of a
+ * generated ABAP class. Format writers consume it and produce the on-disk
+ * layout expected by the respective import flow.
+ */
+type OutputFormat = 'abapgit' | 'gcts';
+interface ClassArtifact {
+  /** Uppercase class name, e.g. 'ZCL_PETSTORE3_CLIENT'. */
+  className: string;
+  /** The printed ABAP source (main class include). */
+  mainSource: string;
+  /** Optional test-class source. If present, must be written alongside. */
+  testSource?: string;
+  /** Optional local include (types) source. */
+  localsDefSource?: string;
+  /** Optional local include (implementation) source — for helper classes emitted alongside the main class. */
+  localsImpSource?: string;
+  /** Optional description used in the .clas.xml metadata (DESCRIPT). */
+  description?: string;
+  /** ADT language key, default 'E'. */
+  language?: string;
+}
+interface InterfaceArtifact {
+  /** UPPERCASE ABAP interface name, e.g. 'ZIF_PETSTORE_TYPES'. */
+  name: string;
+  /** The printed ABAP interface source. */
+  source: string;
+  /** Optional description used in the .intf.xml DESCRIPT. */
+  description?: string;
+  /** ADT language key, default 'E'. */
+  language?: string;
+}
+type ArtifactKind = 'class' | 'interface';
+interface WriteResult {
+  /** Relative paths written, sorted, forward-slash normalised. */
+  files: readonly string[];
+}
+//#endregion
+//#region src/format/abapgit.d.ts
+declare function writeAbapgitLayout(artifact: ClassArtifact, outDir: string): Promise<WriteResult>;
+declare function writeAbapgitInterface(artifact: InterfaceArtifact, outDir: string): Promise<WriteResult>;
+//#endregion
+//#region src/format/gcts.d.ts
+declare function writeGctsLayout(artifact: ClassArtifact, outDir: string): Promise<WriteResult>;
+declare function writeGctsInterface(artifact: InterfaceArtifact, outDir: string): Promise<WriteResult>;
+//#endregion
+//#region src/format/index.d.ts
+declare function writeLayout(artifact: ClassArtifact | InterfaceArtifact, format: OutputFormat, outDir: string): Promise<WriteResult>;
+interface ClientBundle {
+  types: InterfaceArtifact;
+  operations: InterfaceArtifact;
+  exception: ClassArtifact;
+  implementation: ClassArtifact;
+}
+declare function writeClientBundle(artifacts: ClientBundle, format: OutputFormat, outDir: string): Promise<WriteResult>;
+//#endregion
+//#region src/generate.d.ts
+type GenerateTarget = 's4-cloud' | 's4-onprem-modern' | 'on-prem-classic';
+interface GenerateOptions {
+  /** Path to the OpenAPI spec file, a URL, or a pre-parsed spec object. */
+  input: string | URL | object;
+  /** Output directory. Created if missing. */
+  outDir: string;
+  /** Output format (`abapgit` or `gcts`). */
+  format: 'abapgit' | 'gcts';
+  /** Target profile. Only `s4-cloud` is supported in v1. */
+  target?: GenerateTarget;
+  /**
+   * Naming configuration. Exactly one of `names.base` or the individual
+   * overrides must resolve all four global names.
+   */
+  names: NamesConfig;
+  /**
+   * Default server path written into the implementation-class constructor
+   * DEFAULT clause. When omitted, derived from `spec.servers[0].url`
+   * (path component) with a final fallback of `'/'`.
+   */
+  defaultServer?: string;
+  /**
+   * Class-level description embedded in `.clas.xml` / `.intf.xml` metadata.
+   * Defaults to each artifact's own name.
+   */
+  description?: string;
+  /**
+   * When true, nullable fields receive a sibling `<field>_is_null` flag in
+   * the types interface. Default false.
+   */
+  emitNullFlags?: boolean;
+}
+interface GenerateResult {
+  /** All written files, relative to `outDir`, sorted. */
+  files: readonly string[];
+  /** Resolved ABAP global / local names used by the pipeline. */
+  resolvedNames: ResolvedNames;
+  /** Number of type plan entries emitted into the types interface. */
+  typeCount: number;
+  /** Number of operations emitted into the operations interface. */
+  operationCount: number;
+}
+declare function generate(options: GenerateOptions): Promise<GenerateResult>;
+//#endregion
+//#region src/index.d.ts
+declare const OPENAI_CODEGEN_VERSION = "0.2.0";
+//#endregion
+export { ALL_PROFILES, type ArtifactKind, type ClassArtifact, ClientBundle, CollisionError, CyclicTypeError, EmitExceptionClassOptions, EmitExceptionClassResult, EmitOperationsInterfaceOptions, EmitOperationsInterfaceResult, EmitTypesInterfaceOptions, EmitTypesInterfaceResult, type GenerateOptions, type GenerateResult, type GenerateTarget, type HttpClientStrategy, HttpMethod, type IdentKind, type InterfaceArtifact, JsonSchema, JsonSchemaRef, type JsonStrategy, LocalClassesBundle, type NameAllocator, NamesConfig, NamesConfigError, NormalizedHeader, NormalizedMediaType, NormalizedOperation, NormalizedParameter, NormalizedRequestBody, NormalizedResponse, NormalizedServer, NormalizedServerVariable, NormalizedSpec, OAuthFlow, OPENAI_CODEGEN_VERSION, OperationMapping, OperationParamMapping, type OutputFormat, ParameterLocation, type PlanTypesOptions, PolymorphismConflictError, ResolvedNames, ResponseMapperOptions, ResponseMapperResult, type SanitizeOpts, type SchemaVisit, type SchemaVisitor, SecurityRequirement, SecurityScheme, SecuritySchemeApiKey, SecuritySchemeHttp, SecuritySchemeOAuth2, SecuritySchemeOpenIdConnect, SpecInfo, SuccessBodyKind, type TargetProfile, type TargetProfileId, type TypePlan, type TypePlanEntry, UnsupportedSchemaError, WhitelistViolationError, type WriteResult, assertClassAllowed, emitExceptionClass, emitLocalClasses, emitOperationsInterface, emitTypeSection, emitTypesInterface, generate, getProfile, isRef, loadSpec, makeNameAllocator, mapPrimitive, mapResponseHandling, mapSchemaToTypeDef, mapSchemaToTypeRef, normalizeSpec, onPremClassicProfile, operationKey, planTypes, resolveNames, s4CloudProfile, s4OnPremModernProfile, sanitizeIdent, walkSchemas, writeAbapgitInterface, writeAbapgitLayout, writeClientBundle, writeGctsInterface, writeGctsLayout, writeLayout };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/oas/types.ts","../src/oas/load.ts","../src/oas/iterate.ts","../src/profiles/types.ts","../src/profiles/errors.ts","../src/profiles/cloud.ts","../src/profiles/onprem-classic.ts","../src/profiles/onprem-modern.ts","../src/profiles/registry.ts","../src/types/naming.ts","../src/types/plan.ts","../src/types/map.ts","../src/types/emit.ts","../src/types/errors.ts","../src/emit/types-interface.ts","../src/emit/operations-interface.ts","../src/emit/exception-class.ts","../src/emit/local-classes.ts","../src/emit/response-mapper.ts","../src/format/types.ts","../src/format/abapgit.ts","../src/format/gcts.ts","../src/format/index.ts","../src/generate.ts","../src/index.ts"],"mappings":"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"}