Best way to set a non-primitive instance as a default?

[jceipek]

I'm working on a Pydantic emitter for TypeSpec and am trying to figure out the best way to emit a default value that is an instance of another model.
The existing Python code I'm trying to replace includes class instances as default values, where the classes themselves are defined to have default values. For example:

class ErrorResponseUnauthorized(ErrorResponse[APIErrorUnauthorized]):
    error: APIErrorUnauthorized = APIErrorUnauthorized() # Instantiate default

I'm trying to determine the best way to emit something like this from TypeSpec (note that I'm happy to use TypeSpec generics instead of Python generics). Nothing I've tried seems to be valid TypeSpec. Is this possible without a custom decorator of some kind?

What I've Tried

model ErrorResponse<T extends valueof APIError> {
   error: APIError = T; // T refers to a type, but is being used as a value here.
}

model ResponseUnauthorized is ErrorResponse<ApiErrorUnauthorized>; // Argument of type 'ApiErrorUnauthorized' is not assignable to parameter of type 'valueof APIError'

model ErrorResponse<T extends APIError> {
   error: T = valueof T; // Keyword cannot be used as identifier
}

model ResponseUnauthorized is ErrorResponse<ApiErrorUnauthorized>;

model ErrorResponse<T extends APIError> {
   error: T = ...T; // Expression expected
}

model ResponseUnauthorized is ErrorResponse<ApiErrorUnauthorized>;

model ErrorResponse<T extends APIError> {
   error: T = #{...T}; // Type '{}' is not assignable to type 'T'
}

model ResponseUnauthorized is ErrorResponse<ApiErrorUnauthorized>;

model ErrorResponse<T extends APIError> {
   error: T = T(); // Type TemplateParameter is not is not callable.
}

model ResponseUnauthorized is ErrorResponse<ApiErrorUnauthorized>;

model ErrorResponse<T extends valueof APIError> {
   // This seems like it might be a bug? 
   error: typeof T = T; // T refers to a type, but is being used as a value here.
}

// This isn't ideal anyway, because it doesn't emit a separate `ApiErrorUnauthorized`:
model ResponseUnauthorized is ErrorResponse<
  #{ code: APIErrorCode.INVALID_API_KEY,
     message: "API key was invalid, expired, or deleted.",
     suggestion: "Check your API key or create a new one, then try again."
   }>;

model ErrorResponse<T extends APIError> {
   @Pydantic.field("defaultInstance", T) // I could probably make this work
   error: T;
}

model ResponseUnauthorized is ErrorResponse<ApiErrorUnauthorized>;

Additional Context

My TypeSpec definitions for testing include:

enum APIErrorCode {
  INVALID_API_KEY,
  // ...
}

model APIError {
  code: APIErrorCode;
  message: string;
  suggestion?: string;
}

model ApiErrorUnauthorized extends APIError {
  code: APIErrorCode.INVALID_API_KEY = APIErrorCode.INVALID_API_KEY;
  message: string = "API key was invalid, expired, or deleted.";
  suggestion: string = "Check your API key or create a new one, then try again.";
}

The Python code I'm replacing includes:

class APIErrorCode(StrEnum):
    INVALID_API_KEY = "INVALID_API_KEY"

class APIError(BaseModel):
    code: APIErrorCode
    message: str
    suggestion: str | None = None

class APIErrorUnauthorized(APIError):
    code: Literal[APIErrorCode.INVALID_API_KEY] = APIErrorCode.INVALID_API_KEY
    message: str = "API key was invalid, expired, or deleted."
    suggestion: str = "Check your API key or create a new one, then try again."

APIErrorT = TypeVar("APIErrorT", bound=APIError)

class ErrorResponse(ApiSchema, Generic[APIErrorT]):
    error: APIErrorT

[markcowl]

@bterlson @witemple-msft Can one of you please describe plans for template parameter constraints for more object value types?

[bterlson]

Sorry for the delay - I think something like this should be similar to what you want? TypeSpec likes it, though the OpenAPI3 emitter isn't handling object defaults yet and I'm not sure why. Anyway, would something like this work for your use case?

[jceipek]

Thanks, but I don't think so, because the goal is to create different wrapped responses+defaults for different errors.
In the playground you linked, you have:

model ErrorResponse<TError extends valueof APIError> {
  error: typeof TError = ApiErrorUnauthorized;
}

Note that ApiErrorUnauthorized is the default for all errors here regardless of TError. That might work for UnauthorizedResponse is ErrorResponse<ApiErrorUnauthorized>; but not for eg ExpiredResponse is ErrorResponse<ApiErrorExpired>;

I would naively expect something like this to work under the assumption that TError is a value and typeof TError is a type,
but TypeSpec claims "TError refers to a type, but is being used as a value here."

model ErrorResponse<TError extends valueof APIError> {
  error: typeof TError = TError;
}

Moreover, in the playground example, I'm not sure how my emitter would know to translate this:

const ApiErrorUnauthorized: APIError = #{
  code: APIErrorCode.INVALID_API_KEY,
  message: "This request is not authorized",
  suggestion: "Get authorized"
};

to

class APIErrorUnauthorized(APIError):
    code: Literal[APIErrorCode.INVALID_API_KEY] = APIErrorCode.INVALID_API_KEY
    message: str = "API key was invalid, expired, or deleted."
    suggestion: str = "Check your API key or create a new one, then try again."

instead of

APIError(code = APIErrorCode.INVALID_API_KEY, message="API key was invalid, expired, or deleted.", suggestion="Check your API key or create a new one, then try again.")

I want a concrete APIErrorUnauthorized type in addition to an UnauthorizedResponse type.