use std::{collections::BTreeMap, fs, path::Path};
use crate::module::{ApiEndpoint, ApiSignal};
use crate::rest::Lookup;
const HEADER: &str = "// This file is generated by che-rest. Do not edit manually.\n// Run the appropriate che-rest management generator to update it.\n\n";
pub fn generate(
out: &Path,
endpoints: &[ApiEndpoint],
signals: &[ApiSignal],
include_auth: bool,
) -> Result<Vec<String>, std::io::Error> {
fs::create_dir_all(out)?;
let files = [
("api_client.ts", api_client()),
("channels.ts", channels(signals)),
("models.ts", models(endpoints)),
("api.ts", api(endpoints)),
("useModelList.ts", use_model_list()),
("useModelItem.ts", use_model_item()),
];
let mut written = Vec::new();
for (name, content) in files {
let content = content.trim_end_matches('\n').to_owned() + "\n";
fs::write(out.join(name), content)?;
written.push(name.to_owned());
}
if include_auth {
let content = auth().trim_end_matches('\n').to_owned() + "\n";
fs::write(out.join("auth.ts"), content)?;
written.push("auth.ts".to_owned());
}
Ok(written)
}
fn models(endpoints: &[ApiEndpoint]) -> String {
let mut out = HEADER.to_owned();
out.push_str("import type { ListParams } from \"./api_client\";\n\n");
let mut related = BTreeMap::new();
for endpoint in unique_models(endpoints) {
out.push_str(&format!("export interface {} {{\n", endpoint.model_name));
for field in endpoint.fields.iter().filter(|field| !field.write_only) {
out.push_str(&format!(
" {}: {};\n",
field.name,
field_ts_type(endpoint, field)
));
if let Some(model) = field.related_model {
related.insert(last_path_part(model), (field.many, field.rust_type));
}
}
out.push_str("}\n\n");
if endpoint.list_fields != endpoint.fields {
out.push_str(&format!(
"export interface {}ListItem {{\n",
endpoint.model_name
));
for field in endpoint
.list_fields
.iter()
.filter(|field| !field.write_only)
{
out.push_str(&format!(
" {}: {};\n",
field.name,
field_ts_type(endpoint, field)
));
if let Some(model) = field.related_model {
related.insert(last_path_part(model), (field.many, field.rust_type));
}
}
out.push_str("}\n\n");
}
out.push_str(&format!(
"export interface {}Create {{\n",
endpoint.model_name
));
for field in endpoint.fields.iter().filter(|field| {
!field.read_only && (field.related_model.is_none() || field.name == field.source)
}) {
out.push_str(&format!(
" {}{}: {};\n",
field.name,
if field_required(endpoint, field) {
""
} else {
"?"
},
field_ts_type(endpoint, field)
));
}
out.push_str("}\n\n");
out.push_str(&format!(
"export interface {}Update {{\n",
endpoint.model_name
));
for field in endpoint.fields.iter().filter(|field| {
!field.read_only && (field.related_model.is_none() || field.name == field.source)
}) {
out.push_str(&format!(
" {}?: {};\n",
field.name,
field_ts_type(endpoint, field)
));
}
out.push_str("}\n\n");
out.push_str(&format!(
"export interface {}ListParams extends ListParams {{\n",
endpoint.model_name
));
for filter in &endpoint.filters {
let suffix = match filter.lookup {
Lookup::Exact => "",
Lookup::Contains => "__contains",
Lookup::Gt => "__gt",
Lookup::Gte => "__gte",
Lookup::Lt => "__lt",
Lookup::Lte => "__lte",
};
out.push_str(&format!(
" {}{}?: {};\n",
filter.name,
suffix,
filter_ts_type(endpoint, filter.source)
));
}
out.push_str("}\n\n");
}
for model in related.keys() {
if endpoints
.iter()
.any(|endpoint| endpoint.model_name == *model)
{
continue;
}
out.push_str(&format!(
"export interface {} {{\n id: number;\n [key: string]: unknown;\n}}\n\n",
model
));
}
let mut extension_schemas = BTreeMap::new();
for endpoint in endpoints {
for extension in &endpoint.extensions {
for operation in &extension.operations {
if let Some(schema) = &operation.request {
extension_schemas.insert(schema.name, schema.typescript);
}
if let Some((_, schema)) = &operation.response {
extension_schemas.insert(schema.name, schema.typescript);
}
}
}
}
for definition in extension_schemas.into_values() {
out.push_str(definition);
out.push_str("\n\n");
}
out
}
fn api(endpoints: &[ApiEndpoint]) -> String {
let mut out = HEADER.to_owned();
out.push_str("import { apiClient, createModelApi } from \"./api_client\";\nimport type {\n");
for endpoint in unique_models(endpoints) {
out.push_str(&format!(
" {},\n {}Create,\n {}Update,\n {}ListParams,\n",
endpoint.model_name, endpoint.model_name, endpoint.model_name, endpoint.model_name
));
if endpoint.list_fields != endpoint.fields {
out.push_str(&format!(" {}ListItem,\n", endpoint.model_name));
}
}
let mut extension_types = BTreeMap::new();
for endpoint in endpoints {
for extension in &endpoint.extensions {
for operation in &extension.operations {
if let Some(schema) = &operation.request {
extension_types.insert(schema.name, ());
}
if let Some((_, schema)) = &operation.response {
extension_types.insert(schema.name, ());
}
}
}
}
for schema in extension_types.keys() {
out.push_str(&format!(" {schema},\n"));
}
out.push_str("} from \"./models\";\n\n");
for endpoint in endpoints {
let name = api_name(endpoint, endpoints);
let list_item = if endpoint.list_fields == endpoint.fields {
endpoint.model_name.clone()
} else {
format!("{}ListItem", endpoint.model_name)
};
if endpoint.extensions.is_empty() {
out.push_str(&format!(
"export const {name}Api = createModelApi<{}, {}Create, {}Update, {}ListParams, {list_item}>(\"{}\");\n",
endpoint.model_name, endpoint.model_name, endpoint.model_name, endpoint.model_name, endpoint.resource
));
continue;
}
out.push_str(&format!(
"const {name}Crud = createModelApi<{}, {}Create, {}Update, {}ListParams, {list_item}>(\"{}\");\nexport const {name}Api = {{\n ...{name}Crud,\n",
endpoint.model_name, endpoint.model_name, endpoint.model_name, endpoint.model_name, endpoint.resource
));
for extension in &endpoint.extensions {
let mut operations = extension
.operations
.iter()
.filter_map(|operation| operation.client.as_ref().map(|client| (operation, client)))
.collect::<Vec<_>>();
operations.sort_by_key(|(_, client)| client.name);
if operations.is_empty() {
continue;
}
let namespace = operations[0].1.namespace;
out.push_str(&format!(" {namespace}: {{\n"));
for (operation, client) in operations {
let path = operation
.path
.trim_start_matches('/')
.replace("{id}", "${id}");
let response = operation
.response
.as_ref()
.map(|(_, schema)| schema.name)
.unwrap_or("void");
let has_id = path.contains("${id}");
if operation.multipart {
let extras = "if (fields) for (const [key, value] of Object.entries(fields)) data.append(key, value);";
match (operation.method, has_id) {
(crate::HttpMethod::Put | crate::HttpMethod::Post, true) => out.push_str(&format!(
" async {}(id: number, file: Blob, fields?: Record<string, string | Blob>): Promise<{}> {{ const data = new FormData(); data.append(\"file\", file, file instanceof File ? file.name : \"image.png\"); {extras} return (await apiClient.{}<{}>(`{}`, data, {{ headers: {{ \"Content-Type\": undefined }} }})).data; }},\n",
client.name, response, operation.method.openapi_key(), response, path
)),
(crate::HttpMethod::Post, false) => out.push_str(&format!(
" async {}(file: Blob, fields?: Record<string, string | Blob>): Promise<{}> {{ const data = new FormData(); data.append(\"file\", file, file instanceof File ? file.name : \"image.png\"); {extras} return (await apiClient.post<{}>(`{}`, data, {{ headers: {{ \"Content-Type\": undefined }} }})).data; }},\n",
client.name, response, response, path
)),
(crate::HttpMethod::Delete, true) => out.push_str(&format!(
" async {}(id: number, fields?: Record<string, string | Blob>): Promise<void> {{ const data = new FormData(); {extras} await apiClient.delete(`{}`, {{ data, headers: {{ \"Content-Type\": undefined }} }}); }},\n",
client.name, path
)),
_ => {}
}
continue;
}
match (&operation.request, operation.method) {
(Some(request), crate::HttpMethod::Post | crate::HttpMethod::Put | crate::HttpMethod::Patch) if has_id => out.push_str(&format!(
" async {}(id: number, payload: {}): Promise<{}> {{ return (await apiClient.{}<{}>(`{}`, payload)).data; }},\n",
client.name, request.name, response, operation.method.openapi_key(), response, path
)),
(Some(request), crate::HttpMethod::Post | crate::HttpMethod::Put | crate::HttpMethod::Patch) => out.push_str(&format!(
" async {}(payload: {}): Promise<{}> {{ return (await apiClient.{}<{}>(`{}`, payload)).data; }},\n",
client.name, request.name, response, operation.method.openapi_key(), response, path
)),
(None, crate::HttpMethod::Get) if has_id => out.push_str(&format!(
" async {}(id: number): Promise<{}> {{ return (await apiClient.get<{}>(`{}`)).data; }},\n",
client.name, response, response, path
)),
(None, crate::HttpMethod::Post) if has_id => out.push_str(&format!(
" async {}(id: number): Promise<{}> {{ return (await apiClient.post<{}>(`{}`)).data; }},\n",
client.name, response, response, path
)),
(None, crate::HttpMethod::Post) => out.push_str(&format!(
" async {}(): Promise<{}> {{ return (await apiClient.post<{}>(`{}`)).data; }},\n",
client.name, response, response, path
)),
_ => {}
}
}
out.push_str(" },\n");
}
out.push_str("};\n");
}
out
}
fn field_ts_type(endpoint: &ApiEndpoint, field: &che_orm::SerializerField) -> String {
if let Some(model) = field.related_model {
if field.name == field.source {
let nullable = endpoint
.columns
.iter()
.find(|column| column.name == field.source || column.field_name == field.source)
.is_some_and(|column| column.nullable);
return if nullable {
"number | null".into()
} else {
"number".into()
};
}
let ty = last_path_part(model);
return if field.many {
format!("{}[]", ty)
} else {
ty.to_owned()
};
}
if let Some(choices) = endpoint
.columns
.iter()
.find(|column| column.name == field.source || column.field_name == field.source)
.and_then(|column| column.choices.as_ref())
{
let ty = choices
.iter()
.map(|choice| serde_json::to_string(choice).unwrap())
.collect::<Vec<_>>()
.join(" | ");
let nullable = endpoint
.columns
.iter()
.find(|column| column.name == field.source || column.field_name == field.source)
.is_some_and(|column| column.nullable);
return if nullable { format!("{ty} | null") } else { ty };
}
let ty = match field.rust_type {
value
if value.contains("i64")
|| value.contains("i32")
|| value.contains("u64")
|| value.contains("usize") =>
{
"number".into()
}
"bool" => "boolean".into(),
"String" | "&str" | "Option<String>" => "string".into(),
value if value.contains("ImageField") => "string".into(),
value if value.contains("OffsetDateTime") => "string".into(),
_ => "unknown".into(),
};
let nullable = endpoint
.columns
.iter()
.find(|column| column.name == field.source || column.field_name == field.source)
.is_some_and(|column| column.nullable);
if nullable { format!("{ty} | null") } else { ty }
}
fn field_required(endpoint: &ApiEndpoint, field: &che_orm::SerializerField) -> bool {
endpoint
.columns
.iter()
.find(|column| column.name == field.source || column.field_name == field.source)
.is_some_and(|column| !column.nullable && !column.has_default)
}
fn filter_ts_type(endpoint: &ApiEndpoint, source: &str) -> String {
if let Some(choices) = endpoint
.columns
.iter()
.find(|column| column.name == source)
.and_then(|column| column.choices.as_ref())
{
return choices
.iter()
.map(|choice| serde_json::to_string(choice).unwrap())
.collect::<Vec<_>>()
.join(" | ");
}
if source.ends_with("id") || source == "id" {
"number".into()
} else {
"string".into()
}
}
fn last_path_part(value: &str) -> &str {
value.rsplit("::").next().unwrap_or(value).trim()
}
fn lower_first(value: &str) -> String {
let mut chars = value.chars();
chars
.next()
.map(|c| c.to_ascii_lowercase())
.into_iter()
.chain(chars)
.collect()
}
fn unique_models(endpoints: &[ApiEndpoint]) -> Vec<&ApiEndpoint> {
let mut models = BTreeMap::new();
for endpoint in endpoints {
models
.entry(endpoint.model_name.as_str())
.or_insert(endpoint);
}
models.into_values().collect()
}
fn api_name(endpoint: &ApiEndpoint, endpoints: &[ApiEndpoint]) -> String {
if endpoints
.iter()
.filter(|item| item.model_name == endpoint.model_name)
.count()
== 1
{
return lower_first(&endpoint.model_name);
}
endpoint
.resource
.split('/')
.next_back()
.unwrap_or(&endpoint.resource)
.trim_end_matches('s')
.split('-')
.enumerate()
.map(|(index, part)| {
if index == 0 {
part.to_owned()
} else {
let mut chars = part.chars();
chars
.next()
.map(|first| first.to_ascii_uppercase())
.into_iter()
.chain(chars)
.collect()
}
})
.collect()
}
fn api_client() -> String {
let mut out = HEADER.to_owned();
out.push_str(&
r##"import axios from "axios";
export interface BaseEntity { id?: number; }
export interface ListParams {{ ordering?: string; limit?: number; offset?: number; [key: string]: string | number | boolean | null | undefined; }}
export interface PaginatedResponse<T> {{ count: number; results: T[]; }}
export interface ModelApi<T extends BaseEntity, CreateDTO = Partial<T>, UpdateDTO = Partial<T>, Params extends ListParams = ListParams, ListItem extends BaseEntity = T> {{
list: (params?: Params) => Promise<PaginatedResponse<ListItem>>;
retrieve: (id: number) => Promise<T>;
create: (payload: CreateDTO) => Promise<T>;
update: (id: number, payload: UpdateDTO) => Promise<T>;
remove: (id: number) => Promise<void>;
}}
export const apiClient = axios.create({{ baseURL: import.meta.env.VITE_API_BASE_URL ?? "/api", withCredentials: true, xsrfCookieName: "csrf_token", xsrfHeaderName: "X-CSRF-Token", headers: {{ "Content-Type": "application/json" }} }});
let authToken: string | null = null;
export function setAuthToken(token: string | null) {{ authToken = token; }}
apiClient.interceptors.request.use((config) => {{ if (authToken) config.headers.Authorization = `Token ${{authToken}}`; else delete config.headers.Authorization; return config; }});
export function createModelApi<T extends BaseEntity, CreateDTO = Partial<T>, UpdateDTO = Partial<T>, Params extends ListParams = ListParams, ListItem extends BaseEntity = T>(resource: string): ModelApi<T, CreateDTO, UpdateDTO, Params, ListItem> {{
const normalized = resource.endsWith("/") ? resource : `${{resource}}/`;
return {{
async list(params) {{ return (await apiClient.get<PaginatedResponse<ListItem>>(normalized, {{ params }})).data; }},
async retrieve(id) {{ return (await apiClient.get<T>(`${{normalized}}${{id}}/`)).data; }},
async create(payload) {{ return (await apiClient.post<T>(normalized, payload)).data; }},
async update(id, payload) {{ return (await apiClient.patch<T>(`${{normalized}}${{id}}/`, payload)).data; }},
async remove(id) {{ await apiClient.delete(`${{normalized}}${{id}}/`); }},
}};
}}
"##
.replace("{{", "{")
.replace("}}", "}"),
);
out
}
fn channels(signals: &[ApiSignal]) -> String {
let signal_names = if signals.is_empty() {
"string".to_owned()
} else {
signals
.iter()
.map(|signal| format!("\"{}\"", signal.name))
.collect::<Vec<_>>()
.join(" | ")
};
format!(
r#"{HEADER}export type SignalName = {signal_names};
export interface SignalMessage<T = unknown> {{
type: "signal";
signal: SignalName;
payload: T;
}}
export interface ChannelError {{ type: "error"; code: string; detail: string; }}
export interface ChannelSubscriptionEvent {{ type: "subscribed" | "unsubscribed"; signal: SignalName; }}
export type ChannelEvent<T = unknown> = SignalMessage<T> | ChannelError | ChannelSubscriptionEvent;
export interface ChannelClientOptions {{ url?: string; onEvent?: (event: ChannelEvent) => void; onMessage?: (event: SignalMessage) => void; onError?: (event: ChannelError) => void; onClose?: (event: CloseEvent) => void; }}
export class ChannelClient {{
private socket: WebSocket | null = null;
private readonly eventListeners = new Set<(event: ChannelEvent) => void>();
private readonly messageListeners = new Set<(event: SignalMessage) => void>();
private readonly errorListeners = new Set<(event: ChannelError) => void>();
constructor(private readonly options: ChannelClientOptions = {{}}) {{
if (options.onEvent) this.eventListeners.add(options.onEvent);
if (options.onMessage) this.messageListeners.add(options.onMessage);
if (options.onError) this.errorListeners.add(options.onError);
}}
connect(): Promise<void> {{
if (this.socket?.readyState === WebSocket.OPEN) return Promise.resolve();
const socket = new WebSocket(this.options.url ?? defaultChannelUrl());
this.socket = socket;
socket.addEventListener("message", (message) => this.handleMessage(message));
return new Promise((resolve, reject) => {{
socket.addEventListener("open", () => resolve(), {{ once: true }});
socket.addEventListener("error", () => reject(new Error("Unable to connect to WebSocket channels")), {{ once: true }});
socket.addEventListener("close", (event) => this.options.onClose?.(event));
}});
}}
subscribe(signal: SignalName) {{ this.send({{ action: "subscribe", signal }}); }}
unsubscribe(signal: SignalName) {{ this.send({{ action: "unsubscribe", signal }}); }}
onEvent(listener: (event: ChannelEvent) => void) {{ this.eventListeners.add(listener); return () => this.eventListeners.delete(listener); }}
onMessage(listener: (event: SignalMessage) => void) {{ this.messageListeners.add(listener); return () => this.messageListeners.delete(listener); }}
onError(listener: (event: ChannelError) => void) {{ this.errorListeners.add(listener); return () => this.errorListeners.delete(listener); }}
close(code?: number, reason?: string) {{ this.socket?.close(code, reason); this.socket = null; }}
private send(payload: unknown) {{
if (!this.socket || this.socket.readyState !== WebSocket.OPEN) throw new Error("WebSocket channel client is not connected");
this.socket.send(JSON.stringify(payload));
}}
private handleMessage(message: MessageEvent<string>) {{
try {{
const event = JSON.parse(message.data) as ChannelEvent;
for (const listener of this.eventListeners) listener(event);
if (event.type === "signal") for (const listener of this.messageListeners) listener(event);
if (event.type === "error") for (const listener of this.errorListeners) listener(event);
}} catch {{}}
}}
}}
function defaultChannelUrl() {{
const base = new URL(import.meta.env.VITE_API_BASE_URL ?? "/api", window.location.origin);
base.protocol = base.protocol === "https:" ? "wss:" : "ws:";
base.pathname = `${{base.pathname.replace(/\/$/, "")}}/ws/`;
return base.toString();
}}
"#
)
}
fn use_model_list() -> String {
format!(
r#"{HEADER}import {{ onMounted, reactive, ref, shallowRef, watch }} from "vue";
import type {{ BaseEntity, ListParams, ModelApi }} from "./api_client";
export interface UseModelListOptions<Params extends ListParams> {{
defaultFilters?: Partial<Params>;
autoLoad?: boolean;
reloadOnFilterChange?: boolean;
debounceMs?: number;
onError?: (message: string, error: unknown) => void;
}}
export function useModelList<T extends BaseEntity, CreateDTO = Partial<T>, UpdateDTO = Partial<T>, Params extends ListParams = ListParams, ListItem extends BaseEntity = T>(api: ModelApi<T, CreateDTO, UpdateDTO, Params, ListItem>, options: UseModelListOptions<Params> = {{}}) {{
const items = shallowRef<ListItem[]>([]);
const filters = reactive({{ ...(options.defaultFilters ?? {{}}) }} as Params) as Params;
const count = ref(0); const loading = ref(false); const error = ref("");
let loadTimer: ReturnType<typeof setTimeout> | undefined; let skipNextFilterReload = false; let requestSequence = 0;
async function load(params?: Partial<Params>) {{
const request = ++requestSequence;
if (params) {{ skipNextFilterReload = true; Object.assign(filters, params); }}
loading.value = true; error.value = "";
try {{ const response = await api.list(cleanParams(filters) as Params); if (request !== requestSequence) return null; items.value = response.results; count.value = response.count; return response; }}
catch (err) {{ if (request === requestSequence) handleError(err, "Unable to load objects"); return null; }} finally {{ if (request === requestSequence) loading.value = false; }}
}}
async function remove(id: number) {{ loading.value = true; try {{ await api.remove(id); await load(); return true; }} catch (err) {{ handleError(err, "Unable to delete object"); return false; }} finally {{ loading.value = false; }} }}
if (options.reloadOnFilterChange) watch(filters, () => {{ if (skipNextFilterReload) {{ skipNextFilterReload = false; return; }} clearTimeout(loadTimer); loadTimer = setTimeout(() => load(), options.debounceMs ?? 250); }});
if (options.autoLoad) onMounted(() => load());
function handleError(err: unknown, fallback: string) {{ const message = errorMessage(err, fallback); error.value = message; options.onError?.(message, err); }}
return {{ items, filters, count, loading, error, load, remove }};
}}
function cleanParams(params: ListParams) {{ const clean: ListParams = {{}}; for (const [key, value] of Object.entries(params)) if (value !== "" && value !== null && value !== undefined) clean[key] = value; return clean; }}
function errorMessage(err: unknown, fallback: string) {{ if (typeof err === "object" && err && "detail" in err) return String((err as {{ detail: unknown }}).detail); return err instanceof Error ? err.message : fallback; }}
"#
)
}
fn use_model_item() -> String {
format!(
r#"{HEADER}import {{ shallowRef, ref }} from "vue";
import type {{ BaseEntity, ListParams, ModelApi }} from "./api_client";
export interface UseModelItemOptions {{ onError?: (message: string, error: unknown) => void; }}
export function useModelItem<T extends BaseEntity, CreateDTO = Partial<T>, UpdateDTO = Partial<T>, Params extends ListParams = ListParams, ListItem extends BaseEntity = T>(api: ModelApi<T, CreateDTO, UpdateDTO, Params, ListItem>, options: UseModelItemOptions = {{}}) {{
const item = shallowRef<T | null>(null); const loading = ref(false); const error = ref("");
async function retrieve(id: number) {{ return run(() => api.retrieve(id), "Unable to load object"); }}
async function create(payload: CreateDTO) {{ return run(() => api.create(payload), "Unable to create object"); }}
async function update(id: number, payload: UpdateDTO) {{ return run(() => api.update(id, payload), "Unable to update object"); }}
async function remove(id: number) {{ return run(async () => {{ await api.remove(id); item.value = null; return true; }}, "Unable to delete object"); }}
async function run<R>(operation: () => Promise<R>, fallback: string): Promise<R | null> {{ loading.value = true; error.value = ""; try {{ const value = await operation(); if (typeof value === "object" && value !== null) item.value = value as T; return value; }} catch (err) {{ error.value = err instanceof Error ? err.message : fallback; options.onError?.(error.value, err); return null; }} finally {{ loading.value = false; }} }}
return {{ item, loading, error, retrieve, create, update, remove }};
}}
"#
)
}
fn auth() -> String {
format!(
r#"{HEADER}import axios from "axios";
export interface LoginRequest {{ username: string; password: string; }}
export interface AuthUser {{ id: number; username: string; is_staff: boolean; is_admin: boolean; is_superuser: boolean; }}
export interface SessionLoginResponse {{ user: AuthUser; expires_at: string; }}
export interface SessionInfo {{ id: number; user_id: number; revision: number; expires_at: string; }}
export interface SessionMeResponse {{ user: AuthUser; session: SessionInfo | null; }}
export interface TokenLoginResponse {{ token: string; }}
const authClient = axios.create({{
baseURL: import.meta.env.VITE_AUTH_BASE_URL ?? "",
withCredentials: true,
xsrfCookieName: "csrf_token",
xsrfHeaderName: "X-CSRF-Token",
headers: {{ "Content-Type": "application/json" }},
}});
export const sessionAuth = {{
async login(payload: LoginRequest): Promise<SessionLoginResponse> {{
return (await authClient.post<SessionLoginResponse>("/api-session-auth/login/", payload)).data;
}},
async logout(): Promise<void> {{ await authClient.post("/api-session-auth/logout/"); }},
async me(): Promise<SessionMeResponse> {{
return (await authClient.get<SessionMeResponse>("/api-session-auth/me/")).data;
}},
}};
export const tokenAuth = {{
async login(payload: LoginRequest): Promise<TokenLoginResponse> {{
return (await authClient.post<TokenLoginResponse>("/api-token-auth/", payload)).data;
}},
}};
"#
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn multipart_image_actions_generate_formdata_put_and_delete_methods() {
let operation = |method, name, response| crate::ApiOperation {
extension_id: "image-field",
operation_id: format!("image.{name}"),
method,
path: "/boards/{id}/images/preview/".into(),
request: None,
response,
client: Some(crate::ClientMethod {
namespace: "preview",
name,
}),
multipart: true,
openapi: serde_json::json!({}),
};
let endpoint = ApiEndpoint {
app_name: "boards",
model_name: "Board".into(),
resource: "boards".into(),
fields: vec![],
list_fields: vec![],
columns: vec![],
filters: vec![],
extensions: vec![crate::ApiExtension {
id: "image-field",
operations: vec![
operation(
crate::HttpMethod::Put,
"replace",
Some((
200,
crate::ApiSchemaDefinition {
name: "ImageUploadResponse",
openapi: serde_json::json!({}),
typescript: "export interface ImageUploadResponse { url: string; }",
},
)),
),
operation(crate::HttpMethod::Delete, "clear", None),
],
}],
};
let output = api(&[endpoint]);
assert!(output.contains("async replace(id: number, file: Blob"));
assert!(output.contains("data.append(\"file\", file"));
assert!(output.contains("async clear(id: number, fields?"));
assert!(output.contains("apiClient.delete(`boards/${id}/images/preview/`"));
}
#[test]
fn image_field_uses_nullable_storage_column_even_with_db_column_alias() {
let field = che_orm::SerializerField {
name: "preview",
source: "preview",
read_only: true,
write_only: false,
rust_type: "Option<che_orm::ImageField>",
related_model: None,
many: false,
};
let endpoint = ApiEndpoint {
app_name: "diagrams",
model_name: "Board".into(),
resource: "boards".into(),
fields: vec![field],
list_fields: vec![field],
columns: vec![crate::module::ApiColumn {
name: "preview_storage_name",
field_name: "preview",
nullable: true,
has_default: false,
choices: None,
}],
filters: vec![],
extensions: vec![],
};
assert_eq!(field_ts_type(&endpoint, &field), "string | null");
}
#[test]
fn generates_nested_model_and_typed_write_dtos() {
let endpoint = ApiEndpoint {
app_name: "tasks",
model_name: "Task".into(),
resource: "tasks".into(),
fields: vec![
che_orm::SerializerField {
name: "id",
source: "id",
read_only: true,
write_only: false,
rust_type: "i64",
related_model: None,
many: false,
},
che_orm::SerializerField {
name: "author",
source: "author_id",
read_only: true,
write_only: false,
rust_type: "AuthorSerializer",
related_model: Some("che_rest::auth::models::User"),
many: false,
},
che_orm::SerializerField {
name: "name",
source: "name",
read_only: false,
write_only: false,
rust_type: "String",
related_model: None,
many: false,
},
che_orm::SerializerField {
name: "status",
source: "status",
read_only: false,
write_only: false,
rust_type: "TaskStatus",
related_model: None,
many: false,
},
],
list_fields: vec![],
columns: vec![crate::module::ApiColumn {
name: "status",
field_name: "status",
nullable: false,
has_default: false,
choices: Some(vec!["draft", "in_progress", "done"]),
}],
filters: vec![
crate::module::ApiFilter {
name: "name",
source: "name",
lookup: Lookup::Contains,
},
crate::module::ApiFilter {
name: "status",
source: "status",
lookup: Lookup::Exact,
},
],
extensions: vec![],
};
let generated = models(&[endpoint]);
assert!(generated.contains("author: User;"));
assert!(generated.contains("name: string;"));
assert!(generated.contains("status: \"draft\" | \"in_progress\" | \"done\";"));
assert!(generated.contains("name__contains?: string;"));
assert!(generated.contains("status?: \"draft\" | \"in_progress\" | \"done\";"));
assert!(!generated.contains("id: number;\n}\n\nexport interface TaskCreate"));
}
#[test]
fn generated_helpers_keep_typed_and_eventful_apis() {
assert!(use_model_list().contains("UseModelListOptions"));
assert!(use_model_list().contains("ModelApi<T"));
assert!(use_model_item().contains("UseModelItemOptions"));
assert!(channels(&[]).contains("onEvent"));
assert!(channels(&[]).contains("onClose"));
}
#[test]
fn list_serializer_generates_distinct_item_type() {
let id = che_orm::SerializerField {
name: "id",
source: "id",
read_only: true,
write_only: false,
rust_type: "i64",
related_model: None,
many: false,
};
let mut description = id;
description.name = "description";
description.source = "description";
description.rust_type = "String";
let endpoint = ApiEndpoint {
app_name: "knowledge",
model_name: "Module".into(),
resource: "modules".into(),
fields: vec![id, description],
list_fields: vec![id],
columns: vec![],
filters: vec![],
extensions: vec![],
};
let types = models(std::slice::from_ref(&endpoint));
assert!(types.contains("export interface ModuleListItem {\n id: number;\n}"));
assert!(!types.contains("export interface ModuleListItem {\n id: number;\n description"));
assert!(api(&[endpoint]).contains("ModuleListParams, ModuleListItem>"));
}
#[test]
fn duplicate_model_endpoints_use_resource_api_names() {
let user = ApiEndpoint {
app_name: "auth",
model_name: "User".into(),
resource: "users".into(),
fields: vec![],
list_fields: vec![],
columns: vec![],
filters: vec![],
extensions: vec![],
};
let assignees = ApiEndpoint {
app_name: "tasks",
resource: "task-assignees".into(),
..user.clone()
};
let generated = api(&[user, assignees]);
assert_eq!(generated.matches(" UserCreate,\n").count(), 1);
assert!(generated.contains("export const userApi"));
assert!(generated.contains("export const taskAssigneeApi"));
}
}