@typespec/http-server-csharp 0.58.0-alpha.8-dev.1 → 0.58.0-alpha.8-dev.3

package/dist/src/lib/scaffolding.js

@@ -0,0 +1,388 @@
+import { code } from "@typespec/compiler/emitter-framework";
+import { GeneratedFileHeaderWithNullable } from "./boilerplate.js";
+import { LibrarySourceFile } from "./interfaces.js";
+export function getScaffoldingHelpers(emitter, useSwagger, openApiPath) {
+    const sourceFiles = [];
+    sourceFiles.push(new LibrarySourceFile({
+        filename: "IInitializer.cs",
+        emitter: emitter,
+        getContents: getInitializerInterface,
+    }), new LibrarySourceFile({
+        filename: "Initializer.cs",
+        emitter: emitter,
+        getContents: getInitializerImplementation,
+    }), new LibrarySourceFile({
+        filename: "Program.cs",
+        emitter: emitter,
+        getContents: () => getProjectStartup(useSwagger, openApiPath),
+        path: "../",
+    }));
+    return sourceFiles;
+}
+export function getBusinessLogicImplementations(emitter, registrations) {
+    const sourceFiles = [];
+    const mocks = [];
+    for (const [name, impl] of registrations) {
+        sourceFiles.push(new LibrarySourceFile({
+            filename: `${impl.className}.cs`,
+            emitter: emitter,
+            getContents: () => getBusinessLogicImplementation(name, impl),
+            path: "../mocks/",
+        }));
+        mocks.push(impl);
+    }
+    if (mocks.length > 0) {
+        sourceFiles.push(new LibrarySourceFile({
+            filename: "MockRegistration.cs",
+            emitter: emitter,
+            getContents: () => getMockRegistration(mocks),
+            path: "../mocks/",
+        }));
+    }
+    return sourceFiles;
+}
+function getBusinessLogicImplementation(iface, mock) {
+    const methods = [];
+    for (const method of mock.methods) {
+        const methodCode = method.instantiatedReturnType !== undefined
+            ? `return Task.FromResult(_initializer.Initialize<${method.instantiatedReturnType}>());`
+            : "return Task.CompletedTask;";
+        methods.push(`        public ${method.returnType} ${method.methodName}( ${method.methodParams})
+        {
+            ${methodCode}
+        }`);
+    }
+    return `${GeneratedFileHeaderWithNullable}
+
+using System;
+using System.Net;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;${mock.methods.some((m) => m.methodParams.includes("MultipartReader")) ? `\nusing Microsoft.AspNetCore.WebUtilities;` : ""}
+using ${mock.namespace}.Models;
+using TypeSpec.Helpers;
+
+namespace ${mock.namespace}
+{
+    /// <summary>
+    /// This is a mock implementation of the business logic interface for 
+    /// demonstration and early development.  Feel free to overwrite this file.
+    /// Or replace it with another implementation, and register that implementation 
+    /// in the dependency injection container
+    /// </summary>
+    /// <param name="initializer">The initializer class, registered with dependency injection</param>
+    public class ${mock.className} : ${mock.interfaceName}
+    {
+        public ${mock.className}(IInitializer initializer)
+        {
+            _initializer = initializer;
+        }
+
+        private IInitializer _initializer;
+
+${methods.join("\n\n")}
+    }
+}
+  `;
+}
+function getMockRegistration(mocks) {
+    if (mocks.length < 1)
+        return "";
+    const cache = new Map();
+    return `${GeneratedFileHeaderWithNullable}
+
+using Microsoft.AspNetCore.Http.Features;
+${mocks
+        .flatMap((m) => m.usings)
+        .filter((t) => {
+        const result = !cache.has(t);
+        cache.set(t, t);
+        return result;
+    })
+        .flatMap((e) => `using ${e};`)
+        .join("\n")}
+using ${mocks[0].namespace};
+
+namespace TypeSpec.Helpers
+{
+    /// <summary>
+    /// Register Business Logic implementations. Replace with actual implementations when available.
+    /// </summary>
+    public static class MockRegistration
+    {
+        public static void Register(WebApplicationBuilder builder)
+        {
+            builder.Services.AddScoped<IJsonSerializationProvider, JsonSerializationProvider>();
+            // Used for mock implementation only. Remove once business logic interfaces are implemented.
+            builder.Services.AddSingleton<IDictionary<Type, object?>>(new Dictionary<Type, object?>());
+            builder.Services.AddScoped<IInitializer, Initializer>();
+            // Mock business logic implementations
+${mocks.flatMap((m) => `            builder.Services.AddScoped<${m.interfaceName}, ${m.className}>();`).join("\n")}
+            // Included for multipart/form-data support
+            builder.Services.Configure<FormOptions>(options =>
+            {
+                options.MemoryBufferThreshold = int.MaxValue;
+                options.MultipartBodyLengthLimit = int.MaxValue;
+            });
+        }
+    }
+}`;
+}
+function getProjectStartup(useSwagger, openApiPath) {
+    return `${GeneratedFileHeaderWithNullable}
+
+using TypeSpec.Helpers;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container.
+builder.Services.AddControllersWithViews();
+builder.Services.AddEndpointsApiExplorer();
+${useSwagger ? "builder.Services.AddSwaggerGen();" : ""}
+MockRegistration.Register(builder);
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (!app.Environment.IsDevelopment())
+{
+    app.UseExceptionHandler("/Home/Error");
+    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
+    app.UseHsts();
+}
+${useSwagger
+        ? code `else 
+{
+    app.UseSwagger();
+    app.UseSwaggerUI( c=> {
+    c.DocumentTitle = "TypeSpec Generated OpenAPI Viewer";
+        c.SwaggerEndpoint("/openapi.yaml", "TypeSpec Generated OpenAPI Docs");
+        c.RoutePrefix = "swagger";
+    });
+}\n`
+        : ""}
+
+app.UseHttpsRedirection();
+app.UseStaticFiles();
+app.Use(async (context, next) =>
+{
+    context.Request.EnableBuffering();
+    await next();
+});
+${useSwagger
+        ? code `
+app.MapGet("/openapi.yaml", async (HttpContext context) =>
+{
+    var externalFilePath = "${openApiPath}"; // Full path to the file outside the project
+    if (!File.Exists(externalFilePath))
+    {
+        context.Response.StatusCode = StatusCodes.Status404NotFound;
+        await context.Response.WriteAsync("OpenAPI spec not found.");
+        return;
+    }
+    context.Response.ContentType = "application/json";
+    await context.Response.SendFileAsync(externalFilePath);
+});\n`
+        : ""}
+
+app.UseRouting();
+
+app.UseAuthorization();
+
+
+app.MapControllerRoute(
+    name: "default",
+    pattern: "{controller=Home}/{action=Index}/{id?}");
+
+
+app.Run();`;
+}
+function getInitializerInterface() {
+    return `${GeneratedFileHeaderWithNullable}
+
+namespace TypeSpec.Helpers
+{
+    /// <summary>
+    /// Interface for object initialization in mocks
+    /// </summary>
+    public interface IInitializer
+    {
+        /// <summary>
+        /// Initialize an object fo the given type
+        /// </summary>
+        /// <param name="type"> The type to initialize</param>
+        /// <returns>An instance of the given type. Or null if initialization was impossible.</returns>
+        object? Initialize(System.Type type);
+
+        /// <summary>
+        /// Initialize an object of the given type
+        /// </summary>
+        /// <typeparam name="T">The type to initialize</typeparam>
+        /// <returns>An instance of the given type</returns>
+        T Initialize<T>() where T : class, new();
+    }
+}
+`;
+}
+function getInitializerImplementation() {
+    return `${GeneratedFileHeaderWithNullable}
+
+namespace TypeSpec.Helpers
+{
+    /// <summary>
+    /// Default initializer for mock implementations of business logic interfaces
+    /// </summary>
+    public class Initializer : IInitializer
+    {
+        /// <summary>
+        /// Instantiate the initializer.  The cache *should* be instantiated using ASP.Net Core's dependency injection
+        /// </summary>
+        /// <param name="cache"></param>
+        public Initializer(IDictionary<Type, object?> cache)
+        {
+            Cache = cache;
+        }
+
+        internal virtual IDictionary<Type, object?> Cache { get; }
+
+        internal object? CacheAndReturn(Type type, object? instance)
+        {
+            Cache[type] = instance;
+            return instance;
+        }
+
+        /// <summary>
+        /// Initialize an object fo the given type
+        /// </summary>
+        /// <param name="type"> The type to initialize</param>
+        /// <returns>An instance of the given type. Or null if initialization was impossible.</returns>
+        public object? Initialize (Type type)
+        {
+            if (Cache.ContainsKey(type))
+            {
+                return Cache[type];
+            }
+            if (type == typeof(string))
+            {
+                return CacheAndReturn(type, string.Empty);
+            }
+            if (type == typeof(int))
+            {
+                return CacheAndReturn(type, 0);
+            }
+            if (type == typeof(long))
+            {
+                return CacheAndReturn(type, 0L);
+            }
+            if (type == typeof(float))
+            {
+                return CacheAndReturn(type, 0.0f);
+            }
+            if (type == typeof(double))
+            {
+                return CacheAndReturn(type, 0.0);
+            }
+            if (type == typeof(decimal))
+            {
+                return CacheAndReturn(type, 0.0m);
+            }
+            if (type == typeof(bool))
+            {
+                return CacheAndReturn(type, false);
+            }
+            if (type == typeof(byte))
+            {
+                return CacheAndReturn(type, (byte)0);
+            }
+            if (type == typeof(char))
+            {
+                return CacheAndReturn(type, (char)0);
+            }
+            if (type == typeof(short))
+            {
+                return CacheAndReturn(type, (short)0);
+            }
+            if (type == typeof(uint))
+            {
+                return CacheAndReturn(type, (uint)0);
+            }
+            if (type == typeof(ulong))
+            {
+                return CacheAndReturn(type, (ulong)0);
+            }
+            if (type == typeof(ushort))
+            {
+                return CacheAndReturn(type, (ushort)0);
+            }
+            if (type == typeof(sbyte))
+            {
+                return CacheAndReturn(type, (sbyte)0);
+            }
+            if (type == typeof(DateTime))
+            {
+                return CacheAndReturn(type, DateTime.UtcNow);
+            }
+            if (type == typeof(DateTimeOffset))
+            {
+                return CacheAndReturn(type, DateTimeOffset.UtcNow);
+            }
+            if ( type == typeof(TimeSpan))
+            {
+                return CacheAndReturn(type, TimeSpan.Zero);
+            }
+            if (type.IsArray)
+            {
+                var element = type.GetElementType();
+                if (element == null) return null;
+                return CacheAndReturn(type, Array.CreateInstance(element, 0));
+            }
+            if (type.IsClass)
+            {
+                return InitializeClass(type);
+            }
+            var genericType = Nullable.GetUnderlyingType(type);
+            if ( (genericType != null))
+            {
+                return Initialize(genericType);
+            }
+            return new object();
+        }
+
+        /// <summary>
+        /// Initialize an object of the given type
+        /// </summary>
+        /// <typeparam name="T">The type to initialize</typeparam>
+        /// <returns>An instance of the given type</returns>
+        public T Initialize<T>() where T: class, new()
+        {
+            var result = new T();
+            var initialized = InitializeClass(typeof(T), result);
+            return initialized as T ?? result;
+        }
+
+        private object? InitializeClass(Type type, object? instance = null)
+        {
+            if (Cache.ContainsKey(type))
+            {
+                instance = Cache[type];
+                return instance;
+            }
+
+            var result = instance == null ? Activator.CreateInstance(type) : instance;
+            foreach (var property in type.GetProperties())
+            {
+                if (property.CanWrite)
+                {
+                    var propertyType = property.PropertyType;
+                    property.SetValue(result, Initialize(propertyType));
+                }
+            }
+
+            return CacheAndReturn(type, result);
+        }
+    }
+}
+`;
+}
+//# sourceMappingURL=scaffolding.js.map

package/dist/src/lib/scaffolding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffolding.js","sourceRoot":"","sources":["../../../src/lib/scaffolding.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/lib/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EA0BZ,MAAM,oBAAoB,CAAC;AA+C5B,OAAO,EAAE,2BAA2B,EAAoB,MAAM,UAAU,CAAC;AA2BzE,wBAAsB,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,2BAA2B,CAAC,iBAgjD9E"}

package/dist/src/{service.js → lib/service.js}

@@ -4,9 +4,10 @@ import { createRekeyableMap } from "@typespec/compiler/utils";
 import { Visibility, createMetadataInfo, getHeaderFieldName, getHttpOperation, getHttpPart, isHeader, isPathParam, isQueryParam, isStatusCode, } from "@typespec/http";
 import { getResourceOperation } from "@typespec/rest";
 import { execFile } from "child_process";
-import { getSerializationSourceFiles } from "./boilerplate.js";
+import { GeneratedFileHeader, GeneratedFileHeaderWithNullable, getSerializationSourceFiles, } from "./boilerplate.js";
 import { CSharpSourceType, CSharpType, NameCasingType, } from "./interfaces.js";
 import { reportDiagnostic } from "./lib.js";
+import { getBusinessLogicImplementations, getScaffoldingHelpers, } from "./scaffolding.js";
 import { getRecordType, isKnownReferenceType } from "./type-helpers.js";
 import { HttpMetadata, UnknownType, coalesceTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getModelAttributes, getModelInstantiationName, getOperationVerbDecorator, isValueType, } from "./utils.js";
 export async function $onEmit(context) {
@@ -16,12 +17,20 @@ export async function $onEmit(context) {
     const doNotEmit = context.program.compilerOptions.noEmit || false;
     class CSharpCodeEmitter extends CodeTypeEmitter {
         #metadateMap = new Map();
-        #licenseHeader = `// Copyright (c) Microsoft Corporation. All rights reserved.
-    // Licensed under the MIT License.`;
+        #generatedFileHeaderWithNullable = GeneratedFileHeaderWithNullable;
+        #generatedFileHeader = GeneratedFileHeader;
         #sourceTypeKey = "sourceType";
         #libraryFiles = getSerializationSourceFiles(this.emitter);
         #baseNamespace = undefined;
         #emitterOutputType = context.options["output-type"];
+        #emitMocks = context.options["emit-mocks"];
+        #useSwagger = context.options["use-swaggerui"] || false;
+        #openapiPath = context.options["openapi-path"] || "openapi/openapi.yaml";
+        #mockRegistrations = new Map();
+        #mockHelpers = this.#emitMocks === "all"
+            ? getScaffoldingHelpers(this.emitter, this.#useSwagger, this.#openapiPath)
+            : [];
+        #mockFiles = [];
         #metaInfo = createMetadataInfo(this.emitter.getProgram(), {
             canonicalVisibility: Visibility.Read,
             canShareProperty: (p) => true,
@@ -71,8 +80,7 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), en);
             const attributes = getModelAttributes(program, en, enumName);
             this.#metadateMap.set(en, new CSharpType({ name: enumName, namespace: namespace }));
-            return this.emitter.result.declaration(enumName, code `${this.#licenseHeader}
-        // <auto-generated />
+            return this.emitter.result.declaration(enumName, code `${this.#generatedFileHeader}
         
         ${this.#emitUsings()}
         
@@ -150,8 +158,7 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), model);
             const attributes = getModelAttributes(this.emitter.getProgram(), model, className);
             this.#metadateMap.set(model, new CSharpType({ name: className, namespace: namespace }));
-            const decl = this.emitter.result.declaration(className, code `${this.#licenseHeader}
-      // <auto-generated />
+            const decl = this.emitter.result.declaration(className, code `${this.#generatedFileHeader}
 
       ${this.#emitUsings()}
       
@@ -416,8 +423,7 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), iface);
             const attributes = getModelAttributes(this.emitter.getProgram(), iface, ifaceName);
             this.#metadateMap.set(iface, new CSharpType({ name: ifaceName, namespace: namespace }));
-            const decl = this.emitter.result.declaration(ifaceName, code `${this.#licenseHeader}
-      // <auto-generated />
+            const decl = this.emitter.result.declaration(ifaceName, code `${this.#generatedFileHeaderWithNullable}
 
       ${this.#emitUsings()}
 
@@ -458,6 +464,16 @@ export async function $onEmit(context) {
             const builder = new StringBuilder();
             const metadata = new HttpMetadata();
             const context = this.emitter.getContext();
+            const name = `${ensureCSharpIdentifier(this.emitter.getProgram(), iface, iface.name, NameCasingType.Class)}`;
+            const ifaceNamespace = this.#getOrSetBaseNamespace(iface);
+            const namespace = `${ifaceNamespace}`;
+            const mock = {
+                className: name,
+                interfaceName: `I${name}`,
+                methods: [],
+                namespace: namespace,
+                usings: [`${ifaceNamespace}.Models`],
+            };
             for (const [name, operation] of iface.operations) {
                 const doc = getDoc(this.emitter.getProgram(), operation);
                 const returnTypes = [];
@@ -469,15 +485,34 @@ export async function $onEmit(context) {
                 const returnType = returnInfo?.type || UnknownType;
                 const opName = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Method);
                 let opDecl;
+                let opImpl;
                 if (this.#isMultipartRequest(httpOp)) {
-                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`} ${opName}Async( ${this.#emitInterfaceOperationParameters(operation, "MultipartReader reader")});`);
+                    opImpl = {
+                        methodName: `${opName}Async`,
+                        methodParams: `${this.#emitInterfaceOperationParameters(operation, "MultipartReader reader")}`,
+                        returnType: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
+                        instantiatedReturnType: returnType.name === "void"
+                            ? undefined
+                            : `${returnType.getTypeReference(context.scope)}`,
+                    };
+                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnType} ${opImpl.methodName}( ${opImpl.methodParams});`);
                 }
                 else {
-                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`} ${opName}Async( ${this.#emitInterfaceOperationParameters(operation)});`);
+                    opImpl = {
+                        methodName: `${opName}Async`,
+                        methodParams: `${this.#emitInterfaceOperationParameters(operation)}`,
+                        returnType: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
+                        instantiatedReturnType: returnType.name === "void"
+                            ? undefined
+                            : `${returnType.getTypeReference(context.scope)}`,
+                    };
+                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnType} ${opImpl.methodName}( ${opImpl.methodParams});`);
                 }
+                mock.methods.push(opImpl);
                 builder.push(code `${opDecl.value}\n`);
                 this.emitter.emitInterfaceOperation(operation);
             }
+            this.#mockRegistrations.set(mock.interfaceName, mock);
             return builder.reduce();
         }
         interfaceOperationDeclarationContext(operation) {
@@ -717,8 +752,7 @@ export async function $onEmit(context) {
                 const doc = getDoc(this.emitter.getProgram(), union);
                 const attributes = getModelAttributes(program, union, unionName);
                 this.#metadateMap.set(union, new CSharpType({ name: unionName, namespace: namespace }));
-                return this.emitter.result.declaration(unionName, code `${this.#licenseHeader}
-        // <auto-generated />
+                return this.emitter.result.declaration(unionName, code `${this.#generatedFileHeader}
         
         ${this.#emitUsings()}
         
@@ -878,7 +912,7 @@ export async function $onEmit(context) {
             let context = controllers.get(name);
             if (context !== undefined)
                 return context;
-            const sourceFile = this.emitter.createSourceFile(`controllers/${name}ControllerBase.cs`);
+            const sourceFile = this.emitter.createSourceFile(`controllers/${name}Controller.cs`);
             const namespace = this.#getOrSetBaseNamespace(operation);
             const modelNamespace = `${namespace}.Models`;
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Controller;
@@ -928,6 +962,18 @@ export async function $onEmit(context) {
                 if (sourceFile === libFile.source)
                     return libFile.emitted;
             }
+            if (this.#emitMocks === "all") {
+                for (const helper of this.#mockHelpers) {
+                    if (sourceFile === helper.source)
+                        return helper.emitted;
+                }
+            }
+            if (this.#mockFiles.length > 0) {
+                for (const mock of this.#mockFiles) {
+                    if (sourceFile === mock.source)
+                        return mock.emitted;
+                }
+            }
             const emittedSourceFile = {
                 path: sourceFile.path,
                 contents: "",
@@ -952,17 +998,21 @@ export async function $onEmit(context) {
         #emitControllerContents(file) {
             const namespace = file.meta.namespace;
             const contents = new StringBuilder();
-            contents.push(`${this.#licenseHeader}\n`);
-            contents.push("// <auto-generated />\n\n");
+            contents.push(`${this.#generatedFileHeader}\n\n`);
             contents.push(code `${this.#emitUsings(file)}\n`);
             contents.push("\n");
             contents.push(`namespace ${namespace}.Controllers\n`);
             contents.push("{\n");
             contents.push("[ApiController]\n");
-            contents.push(`public abstract partial class ${file.meta["resource"]}Base: ControllerBase\n`);
+            contents.push(`public partial class ${file.meta["resource"]}: ControllerBase\n`);
+            contents.push("{\n");
+            contents.push("\n");
+            contents.push(`public ${file.meta["resource"]}(I${file.meta.resourceName} operations)\n`);
             contents.push("{\n");
+            contents.push(`    ${file.meta.resourceName}Impl = operations;\n`);
+            contents.push("}");
             contents.push("\n");
-            contents.push(code `internal abstract I${file.meta.resourceName} ${file.meta.resourceName}Impl { get;}\n`);
+            contents.push(code `internal virtual I${file.meta.resourceName} ${file.meta.resourceName}Impl { get;}\n`);
             for (const decl of file.globalScope.declarations) {
                 contents.push(decl.value + "\n");
             }
@@ -1089,6 +1139,16 @@ export async function $onEmit(context) {
             for (const source of this.#libraryFiles) {
                 sourceFiles.push(source.source);
             }
+            if (this.#emitMocks === "all") {
+                for (const helper of this.#mockHelpers) {
+                    sourceFiles.push(helper.source);
+                }
+                if (this.#mockRegistrations.size > 0) {
+                    const mocks = getBusinessLogicImplementations(this.emitter, this.#mockRegistrations);
+                    this.#mockFiles.push(...mocks);
+                    sourceFiles.push(...mocks.flatMap((l) => l.source));
+                }
+            }
             const emittedSourceFiles = [];
             for (const source of sourceFiles) {
                 switch (this.#emitterOutputType) {