@stacksjs/orm 0.72.56 → 0.72.60

package/dist/api-routes.d.ts

@@ -0,0 +1,82 @@
+import type { IndexPaginator } from './auto-crud';
+import type { ModelCreateData, ModelRow } from './model-types';
+/** The listing envelope: rows, the flat paginator, and the deprecated `meta`. */
+export declare interface ApiIndexResponse<TRow> extends IndexPaginator {
+  data: TRow[]
+  meta: Record<string, unknown>
+}
+/** The single-row envelope, used by show, store and update alike. */
+export declare interface ApiItemResponse<TRow> {
+  data: TRow
+}
+/** The definition behind a model, whether it was passed bare or via `defineModel`. */
+declare type Definition<M> = M extends { attributes: unknown } ? M : never;
+declare type ApiTrait<M> = Definition<M> extends { traits?: { useApi?: infer A } } ? A : never;
+/** `useApi: { uri: 'products' }` → `'products'`, else the table, else name + "s". */
+declare type ApiUri<M> = ApiTrait<M> extends { uri: infer U extends string }
+    ? U
+    : (Definition<M> extends { table: infer T extends string }
+        ? T
+        : (Definition<M> extends { name: infer N extends string } ? `${Lowercase<N>}s` : never));
+declare type ApiPrefix<M> = ApiTrait<M> extends { prefix: infer P extends string } ? `${P}/` : '';
+/** `/api/{prefix/}{uri}` — the same shape `apiBasePath()` builds. */
+export type ApiBasePathFor<M> = `/api/${ApiPrefix<M>}${ApiUri<M>}`;
+declare type DefaultRoutes = 'index' | 'show' | 'store' | 'update' | 'destroy';
+/** Which of the CRUD verbs this model publishes. */
+declare type EnabledRoutes<M> = ApiTrait<M> extends { routes: infer R extends readonly string[] }
+    ? R[number]
+    : DefaultRoutes;
+declare type Attributes<M> = Definition<M> extends { attributes: infer A } ? A : never;
+/** Attributes flagged `hidden: true`, which never appear in a response. */
+declare type HiddenKeys<M> = {
+  [K in keyof Attributes<M>]: Attributes<M>[K] extends { hidden: true } ? K : never
+}[keyof Attributes<M>];
+/** A row as the generated endpoints actually return it: hidden fields removed. */
+export type ApiRow<M> = Omit<ModelRow<M>, Extract<HiddenKeys<M>, keyof ModelRow<M>>>;
+/** What a write accepts: fillable fields, minus anything hidden. */
+export type ApiWriteData<M> = Omit<ModelCreateData<M>, Extract<HiddenKeys<M>, keyof ModelCreateData<M>>>;
+declare type Params<TId extends string = 'id'> = { [K in TId]: string }
+declare type IndexRoute<M, TBase extends string> = 'index' extends EnabledRoutes<M>
+    ? { [K in `GET ${TBase}`]: { input: Record<string, never>, output: ApiIndexResponse<ApiRow<M>>, params: Record<string, never> } }
+    : Record<string, never>;
+declare type ShowRoute<M, TBase extends string> = 'show' extends EnabledRoutes<M>
+    ? { [K in `GET ${TBase}/{id}`]: { input: Record<string, never>, output: ApiItemResponse<ApiRow<M>>, params: Params } }
+    : Record<string, never>;
+declare type StoreRoute<M, TBase extends string> = 'store' extends EnabledRoutes<M>
+    ? { [K in `POST ${TBase}`]: { input: ApiWriteData<M>, output: ApiItemResponse<ApiRow<M>>, params: Record<string, never> } }
+    : Record<string, never>;
+declare type UpdateRoute<M, TBase extends string> = 'update' extends EnabledRoutes<M>
+    ? {
+        [K in `PUT ${TBase}/{id}` | `PATCH ${TBase}/{id}`]: {
+          input: ApiWriteData<M>
+          output: ApiItemResponse<ApiRow<M>>
+          params: Params
+        }
+      }
+    : Record<string, never>;
+declare type DestroyRoute<M, TBase extends string> = 'destroy' extends EnabledRoutes<M>
+    ? {
+        [K in `DELETE ${TBase}/{id}`]: { input: Record<string, never>, output: undefined, params: Params }
+      } & {
+        [K in `POST ${TBase}/bulk-delete`]: {
+          input: { ids: Array<number | string> }
+          output: { message: string }
+          params: Record<string, never>
+        }
+      }
+    : Record<string, never>;
+/**
+ * Every endpoint `useApi` publishes for this model, as a route map the typed
+ * client understands.
+ *
+ * Intersect several of them - one per model - to describe a whole generated
+ * API, and intersect that with `RoutesOf<typeof api>` to describe an app that
+ * has both generated and hand-written routes.
+ */
+export type ApiRoutesFor<M> = ApiBasePathFor<M> extends infer TBase extends string
+    ? IndexRoute<M, TBase>
+    & ShowRoute<M, TBase>
+    & StoreRoute<M, TBase>
+    & UpdateRoute<M, TBase>
+    & DestroyRoute<M, TBase>
+    : never;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type { PrunableOptions } from './utils/prunable';
 export type { AuditHelpers } from './traits/audit';
 // Re-export soft-delete option types so user code can `satisfies SoftDeleteOptions`.
 export type { SoftDeleteOptions, SoftDeleteHelpers } from './traits/soft-deletes';
+export type * from './api-routes';
 export type { GenerateSchemaOptions, GenerateSchemaResult } from './generate-database-schema';
 export type { CursorPaginator, Paginator, SimplePaginator } from './paginator';
 export type { ResolvedPageArgs } from './paginator-request';