feat(api): ✨ implement basic rest api draft

.vscode/settings.json

@@ -1,3 +1,3 @@
 {
-	"conventionalCommits.scopes": ["model", "chore", "db"]
+	"conventionalCommits.scopes": ["model", "chore", "db", "task", "api"]
 }

README.md

@@ -1,3 +1,3 @@
-# Coh@bit ressources
+# KM - Coh@bit resources manager
 
-Server de gestion des ressources de cohabit.
+Système de gestion des ressources de cohabit.

deno.json

@@ -1,12 +1,13 @@
 {
-	"name": "@cohabit/ressources",
+	"name": "@cohabit/resources-manager",
-	"version": "0.1.2",
+	"version": "0.2.0",
 	"exports": {
-		".": "./mod.ts",
+		"./models": "./src/models/mod.ts",
-		"./models": "./src/models/mod.ts"
+		"./db": "./src/db/mod.ts",
+		"./types": "./types.ts"
 	},
 	"tasks": {
-		"start": "deno run --unstable-kv ./mod.ts"
+		"start": "deno run ./mod.ts"
 	},
 	"fmt": {
 		"singleQuote": true,

deno.lock

@@ -4,6 +4,7 @@
     "specifiers": {
       "jsr:@std/json@^0.223.0": "jsr:@std/json@0.223.0",
       "jsr:@std/streams@^0.223.0": "jsr:@std/streams@0.223.0",
+      "npm:iterator-polyfill": "npm:iterator-polyfill@1.0.9",
       "npm:superjson@1.13.3": "npm:superjson@1.13.3"
     },
     "jsr": {
@@ -28,6 +29,10 @@
         "integrity": "sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==",
         "dependencies": {}
       },
+      "iterator-polyfill@1.0.9": {
+        "integrity": "sha512-YKBrosdKd9nqEaJwpYZjlnax8WtLwCbTo7gnUXrQ3ARA92vD2W8hdOWCRzvotHByDRCvPrFvEFF4M3V53lwAHQ==",
+        "dependencies": {}
+      },
       "superjson@1.13.3": {
         "integrity": "sha512-mJiVjfd2vokfDxsQPOwJ/PtanO87LhpYY88ubI5dUB1Ab58Txbyje3+jpm+/83R/fevaq/107NNhtYBLuoTrFg==",
         "dependencies": {

mod.ts

@@ -1,2 +0,0 @@
-export * from './src/models/mod.ts'
-export { Db } from './src/db/mod.ts'

src/api/hander.ts

@@ -0,0 +1,56 @@
+import type { Db } from '../db/mod.ts'
+import type { Resource } from '../models/mod.ts'
+import type { UUID } from '../../types.ts'
+import type { ResourceBuilder, ResourceType } from './types.ts'
+import { respondJson } from './utils.ts'
+
+export async function resourceHandler<T extends Resource>(
+	type: ResourceType<T>,
+	Builder: ResourceBuilder<T>,
+	db: Db,
+	req: Request,
+	id?: string,
+): Promise<Response> {
+	if (req.method === 'POST') {
+		try {
+			const json = await req.json() as T
+			try {
+				//@ts-expect-error Extends from Resource
+				const resource = Builder.create(json)
+				//@ts-expect-error not a generic
+				const result = await db.resource[type].set(resource)
+				if (result.ok) {
+					//@ts-expect-error generic to fix
+					return respondJson(resource)
+				} else {
+					return respondJson(new Error(`can't insert ${resource} in db`))
+				}
+			} catch (error) {
+				return respondJson(error)
+			}
+		} catch (error) {
+			return respondJson(error)
+		}
+	}
+	if (req.method === 'GET') {
+		if (id === undefined) {
+			return respondJson(new Error('missing "id" for "GET"'))
+		}
+		try {
+			const resource = await db.resource[type].get({ uuid: id as UUID })
+			//@ts-expect-error generic to fix
+			return respondJson(resource)
+		} catch {
+			return respondJson(
+				new Error(`can't find any ${type} with the current uuid ${id}`),
+			)
+		}
+	}
+	if (req.method === 'PATCH') {
+		throw new Error('not implemented')
+	}
+	if (req.method === 'DELETE') {
+		throw new Error('not implemented')
+	}
+	return respondJson(new Error(`method "${req.method}" is not allowed`))
+}

src/api/server.ts

@@ -0,0 +1,81 @@
+// /(users|groups|machines)/:?id
+import { stripTypeS } from '../api/utils.ts'
+import type { Db } from '../db/mod.ts'
+import { Credential, Group, Machine, Service, User } from '../models/mod.ts'
+import type { CredentialCategory } from '../models/src/credential.ts'
+import { resourceHandler } from './hander.ts'
+
+export class Api {
+	static init(db: Db, { base = '/' }: { base: `/${string}` }) {
+		return new Api({ db, base })
+	}
+
+	#db: Db
+	#base: `/${string}`
+
+	private constructor({ db, base }: { db: Db; base: `/${string}` }) {
+		this.#db = db
+		this.#base = base
+	}
+
+	serve() {
+		return Deno.serve((req) => {
+			const url = new URL(req.url)
+
+			if (url.pathname.startsWith(this.#base)) {
+				const base = new URL(this.#base, req.url)
+				return router(req, base, this.#db)
+			}
+
+			return new Response(null, {
+				status: 301,
+				statusText: 'Not allowed base url',
+			})
+		})
+	}
+}
+
+function router(req: Request, base: URL, db: Db): Promise<Response> {
+	const pattern = new URLPattern({ pathname: '/:type/:id?' }, base.href)
+	const match = pattern.exec(req.url)
+
+	if (!match) {
+		return Promise.resolve(
+			new Response(null, {
+				status: 400,
+				statusText: 'Bad request',
+			}),
+		)
+	}
+
+	const { type, id } = match.pathname.groups as {
+		type: string
+		id: string | undefined
+	}
+
+	switch (type) {
+		case 'credentials':
+			return resourceHandler<Credential<CredentialCategory>>(
+				stripTypeS(type),
+				Credential,
+				db,
+				req,
+				id,
+			)
+		case 'groups':
+			return resourceHandler<Group>(stripTypeS(type), Group, db, req, id)
+		case 'machines':
+			return resourceHandler<Machine>(stripTypeS(type), Machine, db, req, id)
+		case 'services':
+			return resourceHandler<Service>(stripTypeS(type), Service, db, req, id)
+		case 'users':
+			return resourceHandler<User>(stripTypeS(type), User, db, req, id)
+		default:
+			return Promise.resolve(
+				new Response(null, {
+					status: 400,
+					statusText: 'Bad request',
+				}),
+			)
+	}
+}

src/api/types.ts

@@ -0,0 +1,29 @@
+import type {
+	Credential,
+	Group,
+	Machine,
+	Resource,
+	Service,
+	User,
+} from '../../src/models/mod.ts'
+import type { JsonValue } from '@std/json'
+import type { CredentialCategory } from '../models/src/credential.ts'
+
+export type ResourceBuilder<T extends Resource> = T extends
+	Credential<CredentialCategory> ? typeof Credential
+	: T extends Group ? typeof Group
+	: T extends Machine ? typeof Machine
+	: T extends Service ? typeof Service
+	: T extends User ? typeof User
+	: never
+
+export type ResourceType<T extends Resource> = T extends
+	Credential<CredentialCategory> ? 'credential'
+	: T extends Group ? 'group'
+	: T extends Machine ? 'machine'
+	: T extends Service ? 'service'
+	: T extends User ? 'user'
+	: never
+
+export type JsonObject = Record<string, JsonValue>
+export type JsonStringifiable = { toJSON(): JsonObject } | JsonObject

src/api/utils.ts

@@ -0,0 +1,38 @@
+import type { JsonStringifiable } from '../api/types.ts'
+
+export function respondJson<T extends JsonStringifiable | Error>(
+	valueOrError: T,
+): Response {
+	if (valueOrError instanceof Error) {
+		const { name, cause, message } = valueOrError
+		return new Response(
+			JSON.stringify({
+				result: 'error',
+				error: { name, cause, message },
+			}),
+			{
+				headers: {
+					'Content-Type': 'application/json; charset=utf-8',
+				},
+				status: 500,
+				statusText: valueOrError.message,
+			},
+		)
+	}
+
+	return new Response(
+		JSON.stringify({
+			result: 'ok',
+			value: valueOrError,
+		}),
+		{
+			headers: {
+				'Content-Type': 'application/json; charset=utf-8',
+			},
+		},
+	)
+}
+
+export function stripTypeS<T extends string>(typeS: `${T}s`): T {
+	return typeS.slice(0, -1) as T
+}

src/db/mod.ts

@@ -3,14 +3,14 @@ import {
 	Group,
 	Machine,
 	type Ref,
-	type Ressource,
+	type Resource,
 	Service,
 	User,
 } from '../models/mod.ts'
 import type { CredentialCategory } from '../models/src/credential.ts'
 
-//!TODO link ressources (get, list)
+//!TODO link resources (get, list)
-//!TODO Purge unused ressources (delete)
+//!TODO Purge unused resources (delete)
 
 export class Db {
 	#kv: Deno.Kv
@@ -27,120 +27,119 @@ export class Db {
 		return this.#kv
 	}
 
-	get prefix(): { ressource: 'ressource' } {
+	get prefix(): { resource: 'resource' } {
 		return {
-			ressource: 'ressource',
+			resource: 'resource',
 		}
 	}
 
-	get ressource() {
+	get resource(): ResourceAccessors {
 		return {
-			credential: this.#ressourceStorage<Credential<CredentialCategory>>(
+			credential: this.#resourceStorage<Credential<CredentialCategory>>(
 				'credential',
 				Credential,
 			),
-			group: this.#ressourceStorage<Group>('group', Group),
+			group: this.#resourceStorage<Group>('group', Group),
-			machine: this.#ressourceStorage<Machine>('machine', Machine),
+			machine: this.#resourceStorage<Machine>('machine', Machine),
-			service: this.#ressourceStorage<Service>('service', Service),
+			service: this.#resourceStorage<Service>('service', Service),
-			user: this.#ressourceStorage<User>('user', User),
+			user: this.#resourceStorage<User>('user', User),
 		}
 	}
 
-	#ressourceStorage<T extends Ressource>(
+	#resourceStorage<T extends Resource>(
-		type: RessourceType<T>,
+		type: ResourceType<T>,
-		Builder: RessourceBuilder<T>,
+		Builder: ResourceBuilder<T>,
-	) {
+	): ResourceStorage<T> {
 		return {
-			get: (ressource: Pick<T, 'uuid'>) =>
+			get: (resource: Pick<T, 'uuid'>) => this.#get<T>(type, Builder, resource),
-				this.#get<T>(type, Builder, ressource),
+			set: (resources: T[]) => this.#set<T>(type, resources),
-			set: (ressources: T[]) => this.#set<T>(type, ressources),
+			delete: (resources: Pick<T, 'uuid'>[]) =>
-			delete: (ressources: Pick<T, 'uuid'>[]) =>
+				this.#delete<T>(type, resources),
-				this.#delete<T>(type, ressources),
 			list: (
-				filter: (ressource: T) => boolean | Promise<boolean> = () => true,
+				filter: (resource: T) => boolean | Promise<boolean> = () => true,
 			) => this.#list<T>(type, Builder, filter),
 			listRef: async (
-				filter: (ressource: T) => boolean | Promise<boolean> = () => true,
+				filter: (resource: T) => boolean | Promise<boolean> = () => true,
 			) => {
-				const ressources: Ref<T>[] = []
+				const resources: Ref<T>[] = []
-				for await (const ressource of this.#list<T>(type, Builder, filter)) {
+				for await (const resource of this.#list<T>(type, Builder, filter)) {
-					ressources.push(ressource.toRef() as Ref<T>)
+					resources.push(resource.toRef() as Ref<T>)
 				}
-				return ressources
+				return resources
 			},
 		}
 	}
 
-	async #get<T extends Ressource>(
+	async #get<T extends Resource>(
-		type: RessourceType<T>,
+		type: ResourceType<T>,
-		Builder: RessourceBuilder<T>,
+		Builder: ResourceBuilder<T>,
 		entry: Pick<T, 'uuid'>,
 	): Promise<T> {
-		const json = await this.#kv.get<RessourceJson<T>>([
+		const json = await this.#kv.get<ResourceJson<T>>([
-			this.prefix.ressource,
+			this.prefix.resource,
 			type,
 			entry.uuid,
 		])
 		if (json.value) {
-			//@ts-expect-error Type union of Ressource types for Builder
+			//@ts-expect-error Type union of Resource types for Builder
 			return Builder.fromJSON(json.value)
 		}
 		throw new ReferenceError(
-			`no ressource.${type} was found with uuid: "${entry.uuid}"`,
+			`no resource.${type} was found with uuid: "${entry.uuid}"`,
 		)
 	}
-	#set<T extends Ressource>(type: RessourceType<T>, entries: T[]) {
+	#set<T extends Resource>(type: ResourceType<T>, entries: T[]) {
 		const atomic = this.#kv.atomic()
 
 		for (const entry of entries) {
 			//! TODO check if `refs` exists
-			const key = [this.prefix.ressource, type, entry.uuid]
+			const key = [this.prefix.resource, type, entry.uuid]
 			atomic.set(key, entry.toJSON())
 		}
 
 		return atomic.commit()
 	}
-	#delete<T extends Ressource>(
+	#delete<T extends Resource>(
-		type: RessourceType<T>,
+		type: ResourceType<T>,
 		entries: Pick<T, 'uuid'>[],
 	): Promise<Deno.KvCommitResult | Deno.KvCommitError> {
 		const atomic = this.#kv.atomic()
 
 		for (const entry of entries) {
 			//! TODO check if `refs` exists
-			atomic.delete([this.prefix.ressource, type, entry.uuid])
+			atomic.delete([this.prefix.resource, type, entry.uuid])
 		}
 
 		return atomic.commit()
 	}
-	async *#list<T extends Ressource>(
+	async *#list<T extends Resource>(
-		type: RessourceType<T>,
+		type: ResourceType<T>,
-		Builder: RessourceBuilder<T>,
+		Builder: ResourceBuilder<T>,
 		filter: (entry: T) => boolean | Promise<boolean>,
 	): AsyncGenerator<T, void, void> {
-		const list = this.#kv.list<RessourceJson<T>>({
+		const list = this.#kv.list<ResourceJson<T>>({
-			prefix: [this.prefix.ressource, type],
+			prefix: [this.prefix.resource, type],
 		})
 		for await (const entry of list) {
 			const value = entry.value
-			//@ts-expect-error Type union of Ressource types for Builder
+			//@ts-expect-error Type union of Resource types for Builder
-			const ressource = Builder.fromJSON(value) as T
+			const resource = Builder.fromJSON(value) as T
-			if (await filter(ressource)) {
+			if (await filter(resource)) {
-				yield ressource
+				yield resource
 			}
 		}
 	}
 }
 
-type RessourceType<T extends Ressource> = T extends
+type ResourceType<T extends Resource> = T extends Credential<CredentialCategory>
-	Credential<CredentialCategory> ? 'credential'
+	? 'credential'
 	: T extends Group ? 'group'
 	: T extends Machine ? 'machine'
 	: T extends Service ? 'service'
 	: T extends User ? 'user'
 	: never
 
-type RessourceBuilder<T extends Ressource> = T extends
+type ResourceBuilder<T extends Resource> = T extends
 	Credential<CredentialCategory> ? typeof Credential
 	: T extends Group ? typeof Group
 	: T extends Machine ? typeof Machine
@@ -148,4 +147,26 @@ type RessourceBuilder<T extends Ressource> = T extends
 	: T extends User ? typeof User
 	: never
 
-type RessourceJson<T extends Ressource> = ReturnType<T['toJSON']>
+type ResourceJson<T extends Resource> = ReturnType<T['toJSON']>
+
+type ResourceStorage<T extends Resource> = {
+	get: (resource: Pick<T, 'uuid'>) => Promise<T>
+	set: (resources: T[]) => Promise<Deno.KvCommitResult | Deno.KvCommitError>
+	delete: (
+		resources: Pick<T, 'uuid'>[],
+	) => Promise<Deno.KvCommitResult | Deno.KvCommitError>
+	list: (
+		filter?: (resource: T) => boolean | Promise<boolean>,
+	) => AsyncGenerator<T, void, void>
+	listRef: (
+		filter?: (resource: T) => boolean | Promise<boolean>,
+	) => Promise<Ref<T>[]>
+}
+
+type ResourceAccessors = {
+	credential: ResourceStorage<Credential<CredentialCategory>>
+	group: ResourceStorage<Group>
+	machine: ResourceStorage<Machine>
+	service: ResourceStorage<Service>
+	user: ResourceStorage<User>
+}

src/models/mod.ts

@@ -1,7 +1,7 @@
-export { Ref, type RefResolver, type RefString } from './utils/ref.ts'
 export { Credential } from './src/credential.ts'
 export { Group } from './src/group.ts'
 export { Machine } from './src/machine.ts'
-export type { Ressource } from './src/ressource.ts'
+export type { Resource } from './src/resource.ts'
 export { Service } from './src/service.ts'
 export { User } from './src/user.ts'
+export { Ref, type RefResolver, type RefString } from './utils/ref.ts'

src/models/src/credential.ts

@@ -1,9 +1,9 @@
 import type { Base64String, ToJson, UUID } from '../../../types.ts'
-import { Ressource } from './ressource.ts'
-import type { Ref } from '../utils/ref.ts'
 import { Avatar } from '../utils/avatar.ts'
+import type { Ref } from '../utils/ref.ts'
+import { Resource, type ResourceJson } from './resource.ts'
 
-export class Credential<T extends CredentialCategory> extends Ressource {
+export class Credential<T extends CredentialCategory> extends Resource {
 	static fromJSON<T extends CredentialCategory>(
 		json: ToJson<Credential<T>>,
 	): Credential<T> {
@@ -48,7 +48,7 @@ export class Credential<T extends CredentialCategory> extends Ressource {
 	private constructor(
 		{ category, store, ...props }:
 			& Pick<Credential<T>, 'category' | 'store'>
-			& Pick<Ressource, 'name' | 'uuid' | 'avatar' | 'createdAt' | 'updatedAt'>,
+			& Pick<Resource, 'name' | 'uuid' | 'avatar' | 'createdAt' | 'updatedAt'>,
 	) {
 		super(props)
 
@@ -89,7 +89,7 @@ export class Credential<T extends CredentialCategory> extends Ressource {
 		})
 	}
 
-	toJSON() {
+	toJSON(): ResourceJson<Credential<T>, 'category' | 'store'> {
 		return {
 			...super.toJSON(),
 			type: this.type,
@@ -107,7 +107,7 @@ export class Credential<T extends CredentialCategory> extends Ressource {
 	}
 }
 
-export interface Credential<T extends CredentialCategory> extends Ressource {
+export interface Credential<T extends CredentialCategory> extends Resource {
 	type: 'credential'
 	category: T
 	store: Readonly<CredentialStore<T>['store']>

src/models/src/group.ts

@@ -1,9 +1,13 @@
 import type { Posix, ToJson, UUID } from '../../../types.ts'
-import { Ressource } from './ressource.ts'
-import { Ref } from '../utils/ref.ts'
 import { Avatar } from '../utils/avatar.ts'
+import { Ref } from '../utils/ref.ts'
+import {
+	Resource,
+	type ResourceJson,
+	type ResourceRefJson,
+} from './resource.ts'
 
-export class Group extends Ressource {
+export class Group extends Resource {
 	static fromJSON(
 		{ posix, groups, ...json }: ToJson<Group>,
 	): Group {
@@ -56,7 +60,7 @@ export class Group extends Ressource {
 	private constructor(
 		{ posix, permissions, groups, ...props }:
 			& Pick<Group, 'posix' | 'permissions' | 'groups'>
-			& Pick<Ressource, 'name' | 'avatar' | 'uuid' | 'createdAt' | 'updatedAt'>,
+			& Pick<Resource, 'name' | 'avatar' | 'uuid' | 'createdAt' | 'updatedAt'>,
 	) {
 		super(props)
 
@@ -114,7 +118,10 @@ export class Group extends Ressource {
 		})
 	}
 
-	toJSON() {
+	toJSON():
+		& ResourceJson<Group, 'permissions'>
+		& { posix: Posix | null }
+		& ResourceRefJson<Group, Group, 'groups'> {
 		return {
 			...super.toJSON(),
 			type: this.type,
@@ -133,7 +140,7 @@ export class Group extends Ressource {
 	}
 }
 
-export interface Group extends Ressource {
+export interface Group extends Resource {
 	type: 'group'
 	posix: Posix | undefined
 	groups: readonly Ref<Group>[]

src/models/src/machine.ts

@@ -1,10 +1,14 @@
-import { Ref } from '../utils/ref.ts'
 import type { ToJson, UrlString } from '../../../types.ts'
-import type { Group } from './group.ts'
-import { Ressource } from './ressource.ts'
 import { Avatar } from '../utils/avatar.ts'
+import { Ref } from '../utils/ref.ts'
+import type { Group } from './group.ts'
+import {
+	Resource,
+	type ResourceJson,
+	type ResourceRefJson,
+} from './resource.ts'
 
-export class Machine extends Ressource {
+export class Machine extends Resource {
 	static fromJSON(
 		{ url, ...json }: ToJson<Machine>,
 	): Machine {
@@ -59,7 +63,7 @@ export class Machine extends Ressource {
 	private constructor(
 		{ tags, url, status, groups, ...props }:
 			& Pick<Machine, 'tags' | 'url' | 'status' | 'avatar' | 'groups'>
-			& Pick<Ressource, 'name' | 'uuid' | 'avatar' | 'createdAt' | 'updatedAt'>,
+			& Pick<Resource, 'name' | 'uuid' | 'avatar' | 'createdAt' | 'updatedAt'>,
 	) {
 		super(props)
 
@@ -108,7 +112,9 @@ export class Machine extends Ressource {
 		})
 	}
 
-	toJSON() {
+	toJSON():
+		& ResourceJson<Machine, 'tags' | 'url' | 'status'>
+		& ResourceRefJson<Machine, Group, 'groups'> {
 		return {
 			...super.toJSON(),
 			type: this.type,
@@ -128,7 +134,7 @@ export class Machine extends Ressource {
 	}
 }
 
-export interface Machine extends Ressource {
+export interface Machine extends Resource {
 	type: 'machine'
 	tags: readonly string[]
 	url: UrlString

src/models/src/resource.ts

@@ -1,12 +1,12 @@
-import { Ref } from '../utils/ref.ts'
 import type { DateString, ToJson, UrlString, UUID } from '../../../types.ts'
 import { regex } from '../../../utils.ts'
+import { Ref } from '../utils/ref.ts'
 
-export class Ressource {
+export class Resource {
 	static fromJSON(
-		json: ToJson<Ressource>,
+		json: ToJson<Resource>,
-	): Ressource {
+	): Resource {
-		return new Ressource({
+		return new Resource({
 			name: json.name,
 			avatar: json.avatar,
 			uuid: json.uuid,
@@ -16,16 +16,16 @@ export class Ressource {
 	}
 
 	static create(
-		{ name, avatar }: Pick<Ressource, 'name' | 'avatar'>,
+		{ name, avatar }: Pick<Resource, 'name' | 'avatar'>,
-	): Ressource {
+	): Resource {
 		const uuid = crypto.randomUUID() as UUID
 		const createdAt = new Date().toISOString() as DateString
 		const updatedAt = createdAt
 
-		return new Ressource({ name, avatar, uuid, createdAt, updatedAt })
+		return new Resource({ name, avatar, uuid, createdAt, updatedAt })
 	}
 
-	static load(_options: never): Ressource {
+	static load(_options: never): Resource {
 		throw new Error('not implemented')
 	}
 
@@ -37,7 +37,7 @@ export class Ressource {
 
 	protected constructor(
 		{ name, avatar, uuid, createdAt, updatedAt }: Pick<
-			Ressource,
+			Resource,
 			'name' | 'avatar' | 'uuid' | 'createdAt' | 'updatedAt'
 		>,
 	) {
@@ -83,9 +83,9 @@ export class Ressource {
 	}
 
 	update(
-		props: Partial<Omit<Ressource, 'type' | 'uuid' | 'createdAt'>>,
+		props: Partial<Omit<Resource, 'type' | 'uuid' | 'createdAt'>>,
-	): Ressource {
+	): Resource {
-		return new Ressource({
+		return new Resource({
 			name: this.name,
 			avatar: this.avatar,
 			uuid: this.uuid,
@@ -95,7 +95,10 @@ export class Ressource {
 		})
 	}
 
-	toJSON() {
+	toJSON(): ResourceJson<
+		Resource,
+		'type' | 'uuid' | 'name' | 'avatar' | 'createdAt' | 'updatedAt'
+	> {
 		return {
 			type: this.type,
 			uuid: this.uuid,
@@ -110,12 +113,12 @@ export class Ressource {
 		return `Ressource (${JSON.stringify(this)})`
 	}
 
-	toRef(): Ref<Ressource> {
+	toRef(): Ref<Resource> {
-		return Ref.fromRessource(this)
+		return Ref.fromResource(this)
 	}
 }
 
-export interface Ressource {
+export interface Resource {
 	type: 'user' | 'machine' | 'service' | 'group' | 'credential'
 	uuid: UUID
 	name: string
@@ -123,3 +126,24 @@ export interface Ressource {
 	createdAt: DateString
 	updatedAt: DateString
 }
+
+export type ResourceJson<T extends Resource, K extends keyof T> = Readonly<
+	Pick<
+		T,
+		| 'type'
+		| 'uuid'
+		| 'name'
+		| 'avatar'
+		| 'createdAt'
+		| 'updatedAt'
+		| K
+	>
+>
+
+export type ResourceRefJson<
+	T extends Resource,
+	Ref extends Resource,
+	K extends keyof T,
+> = {
+	[k in K]: Readonly<ReturnType<ReturnType<Ref['toRef']>['toString']>[]>
+}

src/models/src/service.ts

@@ -1,10 +1,14 @@
-import { Ref } from '../utils/ref.ts'
 import type { ToJson, UrlString } from '../../../types.ts'
-import type { Group } from './group.ts'
-import { Ressource } from './ressource.ts'
 import { Avatar } from '../utils/avatar.ts'
+import { Ref } from '../utils/ref.ts'
+import type { Group } from './group.ts'
+import {
+	Resource,
+	type ResourceJson,
+	type ResourceRefJson,
+} from './resource.ts'
 
-export class Service extends Ressource {
+export class Service extends Resource {
 	static fromJSON(
 		{ groups, ...json }: ToJson<Service>,
 	): Service {
@@ -62,7 +66,7 @@ export class Service extends Ressource {
 		tags,
 		url,
 		groups,
-		...ressource
+		...resource
 	}: Pick<
 		Service,
 		| 'uuid'
@@ -75,7 +79,7 @@ export class Service extends Ressource {
 		| 'groups'
 		| 'avatar'
 	>) {
-		super(ressource)
+		super(resource)
 
 		if (!['web', 'fs', 'git'].includes(category)) {
 			throw new TypeError(
@@ -126,7 +130,9 @@ export class Service extends Ressource {
 		})
 	}
 
-	toJSON() {
+	toJSON():
+		& ResourceJson<Service, 'category' | 'tags' | 'url'>
+		& ResourceRefJson<Service, Group, 'groups'> {
 		return {
 			...super.toJSON(),
 			type: this.type,
@@ -146,7 +152,7 @@ export class Service extends Ressource {
 	}
 }
 
-export interface Service extends Ressource {
+export interface Service extends Resource {
 	type: 'service'
 	category: ServiceCategory
 	tags: readonly string[]

src/models/src/user.ts

@@ -1,12 +1,16 @@
-import { Ref } from '../utils/ref.ts'
 import type { Login, MailAddress, Posix, ToJson } from '../../../types.ts'
 import { regex, toLogin } from '../../../utils.ts'
+import { Avatar } from '../utils/avatar.ts'
+import { Ref } from '../utils/ref.ts'
 import type { Credential, CredentialCategory } from './credential.ts'
 import type { Group } from './group.ts'
-import { Ressource } from './ressource.ts'
+import {
-import { Avatar } from '../utils/avatar.ts'
+	Resource,
+	type ResourceJson,
+	type ResourceRefJson,
+} from './resource.ts'
 
-export class User extends Ressource {
+export class User extends Resource {
 	static fromJSON(json: ToJson<User>): User {
 		if (json.type !== 'user') {
 			throw new TypeError(`type is "${json.type}" but "user" is required`)
@@ -112,7 +116,7 @@ export class User extends Ressource {
 		groups,
 		posix,
 		credentials,
-		...ressource
+		...resource
 	}: Pick<
 		User,
 		| 'uuid'
@@ -127,7 +131,7 @@ export class User extends Ressource {
 		| 'avatar'
 		| 'credentials'
 	>) {
-		super(ressource)
+		super(resource)
 		this.#lastname = lastname
 		this.#firstname = firstname
 		if (!regex.mailAddress) {
@@ -190,9 +194,14 @@ export class User extends Ressource {
 		})
 	}
 
-	toJSON() {
+	toJSON():
+		& ResourceJson<User, 'lastname' | 'firstname' | 'login' | 'mail'>
+		& { posix: Posix | null }
+		& ResourceRefJson<User, Group, 'groups'>
+		& ResourceRefJson<User, Credential<CredentialCategory>, 'credentials'> {
 		return {
 			...super.toJSON(),
+			type: this.type,
 			lastname: this.lastname,
 			firstname: this.firstname,
 			login: this.login,
@@ -213,7 +222,7 @@ export class User extends Ressource {
 	}
 }
 
-export interface User extends Ressource {
+export interface User extends Resource {
 	type: 'user'
 	lastname: string
 	firstname: string

src/models/utils/ref.ts

@@ -1,28 +1,28 @@
-import type { Db } from '../../db/mod.ts'
 import type { UUID } from '../../../types.ts'
+import type { Db } from '../../db/mod.ts'
 import {
 	Credential,
 	Group,
 	Machine,
-	type Ressource,
+	type Resource,
 	Service,
 	User,
 } from '../mod.ts'
 
-export type RefString<T extends Ressource> =
+export type RefString<T extends Resource> =
 	| `@ref/${T['type']}#${UUID}`
 	| Ref<T>
-export type RefResolver<T extends Ressource> = (
+export type RefResolver<T extends Resource> = (
 	ref: RefString<T>,
 ) => T | Promise<T>
-export class Ref<T extends Ressource> extends String {
+export class Ref<T extends Resource> extends String {
-	static #toString<T extends Ressource>(
+	static #toString<T extends Resource>(
 		{ uuid, type }: { uuid: UUID; type: T['type'] },
 	) {
 		return `@ref/${type}#${uuid}` as const
 	}
 
-	static parse<T extends Ressource>(
+	static parse<T extends Resource>(
 		string: RefString<T>,
 	): { type: T['type']; uuid: UUID } {
 		const [_, value] = string.split('/')
@@ -31,28 +31,28 @@ export class Ref<T extends Ressource> extends String {
 		return { type, uuid } as const
 	}
 
-	static fromRessource<T extends Ressource>(ressource: T): Ref<T> {
+	static fromResource<T extends Resource>(resource: T): Ref<T> {
-		return new Ref<T>(ressource)
+		return new Ref<T>(resource)
 	}
 
-	static fromString<T extends Ressource>(string: RefString<T>): Ref<T> {
+	static fromString<T extends Resource>(string: RefString<T>): Ref<T> {
 		return new Ref<T>(Ref.parse(string))
 	}
 
 	static dbResolver(
 		db: Db,
-	): <T extends Ressource>(ref: RefString<T>) => Promise<T> {
+	): <T extends Resource>(ref: RefString<T>) => Promise<T> {
-		return <T extends Ressource>(ref: RefString<T>): Promise<T> => {
+		return <T extends Resource>(ref: RefString<T>): Promise<T> => {
 			const { type, uuid } = Ref.parse(ref)
 			//@ts-expect-error force type casting to fix
-			return db.ressource[type].get({ uuid })
+			return db.resource[type].get({ uuid })
 		}
 	}
 
 	static restResolver(
 		endpoint: string | URL,
-	): <T extends Ressource>(ref: RefString<T>) => Promise<T> {
+	): <T extends Resource>(ref: RefString<T>) => Promise<T> {
-		return async <T extends Ressource>(ref: RefString<T>): Promise<T> => {
+		return async <T extends Resource>(ref: RefString<T>): Promise<T> => {
 			const { type, uuid } = Ref.parse(ref)
 			const url = new URL(`${type}s/${uuid}`, endpoint)
 			const response = await fetch(url)