@lucashw68/nsdb 1.0.0-rc.2

package/runtime/composables/useNsdbProfile.ts

@@ -0,0 +1,119 @@
+import { computed, ref, watch } from 'vue'
+import { useSupabaseUser } from '#imports'
+import { useSupabaseApi } from './useSupabaseApi'
+
+export type NsdbProfileDefaults<TProfile extends Record<string, any>> = (
+	user: any
+) => Partial<TProfile>
+
+export interface UseNsdbProfileOptions<TProfile extends Record<string, any>> {
+	table?: string
+	select?: string
+	userColumn?: string
+	idColumn?: keyof TProfile | string
+	createIfMissing?: boolean
+	defaults?: NsdbProfileDefaults<TProfile>
+	immediate?: boolean
+}
+
+export function useNsdbProfile<TProfile extends Record<string, any> = Record<string, any>>(
+	options: UseNsdbProfileOptions<TProfile> = {}
+) {
+	const {
+		table = 'profiles',
+		select = '*',
+		userColumn = 'user_id',
+		idColumn = 'id',
+		createIfMissing = false,
+		defaults = (user: any) => ({ [userColumn]: user.id, email: user.email } as unknown as Partial<TProfile>),
+		immediate = true,
+	} = options
+
+	const user = useSupabaseUser()
+	const api = useSupabaseApi()
+	const profile = ref<TProfile | null>(null)
+	const loading = ref(false)
+	const error = ref<unknown>(null)
+
+	const profileId = computed(() => {
+		const currentProfile = profile.value as Record<string, any> | null
+		return currentProfile?.[idColumn as string] ?? null
+	})
+
+	async function createProfile() {
+		if (!user.value?.id) return null
+
+		const payload = defaults(user.value)
+		const response = await api.create<TProfile>(table, payload)
+
+		if (!response.success) {
+			throw response.error
+		}
+
+		profile.value = response.data ?? null
+		return profile.value
+	}
+
+	async function refresh() {
+		if (!user.value?.id) {
+			profile.value = null
+			return null
+		}
+
+		loading.value = true
+		error.value = null
+
+		try {
+			const response = await api.all<TProfile>(table, {
+				select,
+				where: {
+					[userColumn]: user.value.id,
+				},
+				limit: 1,
+				offset: 0,
+			})
+
+			if (!response.success) {
+				throw response.error
+			}
+
+			profile.value = response.data?.[0] ?? null
+
+			if (!profile.value && createIfMissing) {
+				return await createProfile()
+			}
+
+			return profile.value
+		} catch (profileError) {
+			error.value = profileError
+			throw profileError
+		} finally {
+			loading.value = false
+		}
+	}
+
+	async function ensureProfile() {
+		if (profile.value) return profile.value
+		return await refresh()
+	}
+
+	if (immediate) {
+		watch(
+			() => user.value?.id ?? null,
+			() => {
+				refresh().catch(() => {})
+			},
+			{ immediate: true }
+		)
+	}
+
+	return {
+		user,
+		profile,
+		profileId,
+		loading,
+		error,
+		refresh,
+		ensureProfile,
+	}
+}

package/runtime/composables/useNsdbSchemas.ts

@@ -0,0 +1,176 @@
+// @lucashw68/nsdb/runtime/composables/useNsdbSchemas.ts
+import { computed } from 'vue'
+import type { EntityField, EntityRelation } from '@lucashw68/nsdb/types/entities'
+import type { ModelQuery } from '@lucashw68/nsdb/types/model'
+
+type Schema = Record<string, EntityField>
+
+export function useNsdbSchema(
+	schema: Schema | null | undefined,
+	relations: EntityRelation[] = [],
+) {
+	// Sécurise le schema pour éviter les erreurs si null / undefined
+	const safeSchema: Schema = schema && typeof schema === 'object'
+		? schema
+		: ({} as Schema)
+
+	// ------------------------------------------------------------
+	// Champs & editableKeys
+	// ------------------------------------------------------------
+
+	const fields = Object.keys(safeSchema)
+
+	const editableKeys = computed(() =>
+		Object.entries(safeSchema)
+			.filter(([, field]) => !field.readonly && field.editable !== false && !field.serverOnly)
+			.map(([key]) => key)
+	)
+
+	// ------------------------------------------------------------
+	// Fabrique d'objet vide basé sur le schema
+	// ------------------------------------------------------------
+
+	function createDraftFromSchema(): Record<string, unknown> {
+		const result: Record<string, any> = {}
+
+		for (const [key, definition] of Object.entries(safeSchema)) {
+			if (definition.readonly || definition.editable === false || definition.serverOnly) continue
+
+			if ('default' in definition) {
+				result[key] = definition.default
+			} else if (definition.hasDefault) {
+				// Keep the key renderable while omitting it from create payloads.
+				result[key] = undefined
+			} else if (definition.nullable) {
+				result[key] = null
+			} else if (definition.type === 'checkbox') {
+				result[key] = false
+			} else {
+				result[key] = null
+			}
+		}
+
+		return result
+	}
+
+	/** @deprecated Use `createDraftFromSchema()`. Scheduled for removal before 1.0. */
+	const emptyFromSchema = createDraftFromSchema
+
+	// ------------------------------------------------------------
+	// Helpers pour les relations → select Supabase
+	// ------------------------------------------------------------
+
+	function aliasFromColumn(column: string, relation: EntityRelation) {
+		if (typeof column === 'string' && column.endsWith('_id')) {
+			const base = column.slice(0, -3)
+			return base || relation.referencedTable
+		}
+		return relation.referencedTable
+	}
+
+	/**
+	 * Construit une chaîne `select` pour Supabase à partir d'un schema.
+	 * Exemple : "*, playlist:playlists(*), profile:profiles(*)"
+	 *
+	 * - Si aucun schema n'est fourni, on utilise celui passé au hook.
+	 */
+
+	function buildSelectFromSchema(
+		schema: Schema | null | undefined = safeSchema,
+		baseSelect?: string,
+		include?: readonly string[],
+	): string {
+		if (!schema || typeof schema !== 'object') {
+			console.warn('[buildSelectFromSchema] invalid schema, returning baseSelect only')
+			return String(baseSelect ?? '*')
+		}
+
+		const selectedBase = baseSelect ?? Object.entries(schema)
+			.filter(([, field]) => field.selectable !== false && !field.serverOnly)
+			.map(([column]) => column)
+			.join(', ')
+
+		const relationParts: string[] = []
+		if (include) {
+			for (const alias of include) {
+				const relation = relations.find(candidate => candidate.alias === alias)
+				if (!relation) {
+					throw new Error(`[nsdb] Unknown relation include "${alias}".`)
+				}
+				const resource = relation.embedResource ?? relation.referencedTable
+				const needsConstraintHint = relation.direction !== 'through' && resource === relation.referencedTable
+				const fkSuffix = needsConstraintHint && relation.foreignKeyName ? `!${relation.foreignKeyName}` : ''
+				relationParts.push(`${alias}:${resource}${fkSuffix}(*)`)
+			}
+		}
+
+		for (const [column, field] of include ? [] : Object.entries(schema)) {
+			if (!field || typeof field !== 'object') continue
+			if (!field.relation) continue
+
+			const rel = field.relation
+
+			// Pour l'instant, tous les belongsTo et hasOne sont inclus.
+			// Les hasMany sont exclus pour éviter les charges trop lourdes.
+			// À affiner, par exemple, filtrer certains hasOne.
+			if (rel.kind !== 'belongsTo' && rel.kind !== 'hasOne') continue
+
+			const alias = rel.alias ?? aliasFromColumn(column, rel)
+			const resource = rel.embedResource ?? rel.referencedTable
+			const needsConstraintHint = resource === rel.referencedTable
+			const fkSuffix = needsConstraintHint && rel.foreignKeyName ? `!${rel.foreignKeyName}` : ''
+
+			const part = `${alias}:${resource}${fkSuffix}(*)`
+			relationParts.push(part)
+		}
+
+		if (!relationParts.length) {
+			return String(selectedBase || '*')
+		}
+
+		return [String(selectedBase || '*'), ...relationParts].join(', ')
+	}
+
+	// ------------------------------------------------------------
+	// bindModel : plugge un useSupabaseModel sur le schema
+	// ------------------------------------------------------------
+
+	function bindModel<TRow, TRelations extends Record<string, unknown> = Record<never, never>>(model: {
+		fetch: (query?: ModelQuery<string, Extract<keyof TRow, string>>) => Promise<TRow[]>
+		refresh: (query?: ModelQuery<string, Extract<keyof TRow, string>>) => Promise<TRow[]>
+	}) {
+		/**
+		 * Récupère une liste d'éléments avec :
+		 * - select auto (relations) basé sur le schema
+		 * - support de where, orderBy, limit, offset via model.fetch(query)
+		 */
+		const fetch = async <TInclude extends keyof TRelations & string = never>(
+			query: ModelQuery<TInclude, Extract<keyof TRow, string>> = {},
+		): Promise<Array<TRow & Pick<TRelations, TInclude>>> => {
+			const select = query.select ?? buildSelectFromSchema(safeSchema, undefined, query.include)
+			const finalQuery = { ...query, select }
+
+			const rows = await model.fetch(finalQuery)
+			return Array.isArray(rows) ? (rows as Array<TRow & Pick<TRelations, TInclude>>) : []
+		}
+
+		const refresh = async <TInclude extends keyof TRelations & string = never>(
+			query: ModelQuery<TInclude, Extract<keyof TRow, string>> = {},
+		): Promise<Array<TRow & Pick<TRelations, TInclude>>> => {
+			const select = query.select ?? buildSelectFromSchema(safeSchema, undefined, query.include)
+			const rows = await model.refresh({ ...query, select })
+			return Array.isArray(rows) ? (rows as Array<TRow & Pick<TRelations, TInclude>>) : []
+		}
+
+		return { fetch, refresh }
+	}
+
+	return {
+		fields,
+		editableKeys,
+		buildSelectFromSchema,
+		createDraftFromSchema,
+		emptyFromSchema,
+		bindModel,
+	}
+}

package/runtime/composables/useSupabaseApi.ts

@@ -0,0 +1,177 @@
+import { useSupabaseClient } from '#imports'
+import type {
+	ListOptions,
+} from '@lucashw68/nsdb/types/list'
+import { applyListOptions, applySearch, applyWhereFilters } from '../query'
+
+type QueryBuilder = any
+type MutationPayload = Record<string, unknown> | Record<string, unknown>[]
+
+export interface SupabaseApiSuccess<T> {
+	success: true
+	error: undefined
+	data: T | null
+	count: number | null
+}
+
+export interface SupabaseApiFailure<T> {
+	success: false
+	error: unknown
+	data: T
+	count: number | null
+}
+
+export type SupabaseApiResponse<T> = SupabaseApiSuccess<T> | SupabaseApiFailure<T>
+export type SupabaseApiListResponse<T> = SupabaseApiResponse<T[]>
+
+/** #########################################################
+ * Handle Responses
+ * ##########################################################
+*/
+
+function handleResponse<T>(
+	payload: { data: T | null; error: unknown; count?: number | null },
+	context: string
+): SupabaseApiResponse<T> {
+	const { data, error, count } = payload
+
+	if (error) {
+		console.error(`❌ [${context}]`, error)
+		return {
+			success: false as const,
+			error,
+			data: undefined as unknown as T,
+			count: count ?? null,
+		}
+	}
+
+	return {
+		success: true as const,
+		error: undefined,
+		data,
+		count: count ?? null,
+	}
+}
+
+function handleListResponse<T>(
+	data: T[] | null,
+	count: number | null,
+	error: unknown,
+	context: string
+) {
+	if (error) {
+		console.error(`❌ [${context}]`, error)
+		return {
+		success: false as const,
+		error,
+		data: [] as T[],
+		count: null as number | null,
+		}
+	}
+
+	return {
+		success: true as const,
+		error: undefined,
+		data: (data ?? []) as T[],
+		count: typeof count === 'number' ? count : null,
+	}
+}
+
+/** Canonical low-level response-object API. */
+
+export const useSupabaseApi = () => {
+	const supabaseClient = useSupabaseClient?.()
+	if (!supabaseClient) {
+		throw new Error('[nsdb] Supabase client not found. Install @nuxtjs/supabase.')
+	}
+	// This advanced API deliberately accepts runtime table names. Recent typed
+	// Supabase clients narrow `from()` to generated relations, so keep the
+	// unavoidable dynamic cast at this single low-level escape-hatch boundary.
+	const from = (resource: string): QueryBuilder => (
+		supabaseClient.from as unknown as (relation: string) => QueryBuilder
+	)(resource)
+
+	async function all<T = any>(
+		resource: string,
+		options: ListOptions = {},
+	): Promise<SupabaseApiListResponse<T>> {
+		const selectClause = options.select ?? '*'
+
+		let q: QueryBuilder = from(resource).select(selectClause, { count: 'exact' })
+		q = applyWhereFilters(q, options.where)
+		q = applySearch(q, options)
+		q = applyListOptions(q, options)
+
+		const { data, error, count } = await q
+		return handleListResponse<T>(data, count ?? null, error, `ALL ${resource}`)
+	}
+
+	async function getById<T = any>(
+		resource: string,
+		id: string | number,
+		options: { key?: string; select?: string } = {},
+	) {
+		const { data, error } = await from(resource)
+			.select(options.select ?? '*')
+			.eq(options.key ?? 'id', id)
+			.limit(1)
+			.single()
+
+		return handleResponse<T>({ data, error }, `GET ${resource}/${id}`)
+	}
+
+	async function create<T = any>(resource: string, payload: MutationPayload) {
+		const { data, error } = await from(resource).insert(payload).select().single()
+		return handleResponse<T>({ data, error }, `CREATE ${resource}`)
+	}
+
+	async function update<T = any>(
+		resource: string,
+		id: string | number,
+		payload: MutationPayload,
+		options: { key?: string } = {},
+	) {
+		const { data, error } = await from(resource).update(payload).eq(options.key ?? 'id', id).select()
+		return handleResponse<T | T[]>({ data, error }, `UPDATE ${resource}/${id}`)
+	}
+
+	async function remove(resource: string, id: string | number, options: { key?: string } = {}) {
+		const { data, error } = await from(resource).delete().eq(options.key ?? 'id', id)
+		return handleResponse({ data, error }, `DELETE ${resource}/${id}`)
+	}
+
+	async function upsert<T = any>(resource: string, payload: MutationPayload, options: { onConflict?: string } = {}) {
+		const upsertOptions = options.onConflict ? { onConflict: options.onConflict } : undefined
+		const q: QueryBuilder = from(resource)
+			.upsert(payload, upsertOptions)
+			.select()
+		const { data, error } = await q
+		return handleResponse<T | T[]>({ data, error }, `UPSERT ${resource}`)
+	}
+
+	async function count(resource: string, where?: { property: string; value: string | number }) {
+		let q: QueryBuilder = from(resource).select('*', { count: 'exact', head: true })
+		if (where) q = q.eq(where.property, where.value)
+		const { count, error } = await q
+		return handleResponse<number | null>({ data: count ?? null, error }, `COUNT ${resource}`)
+	}
+
+	async function findOne<T = any>(resource: string, options: ListOptions) {
+		const { select = '*', where } = options
+		let q: QueryBuilder = from(resource).select(select)
+		q = applyWhereFilters(q, where)
+		const { data, error } = await q.limit(1).single()
+		return handleResponse<T>({ data, error }, `FIND ONE ${resource}`)
+	}
+
+	return {
+		all,
+		getById,
+		create,
+		update,
+		remove,
+		upsert,
+		count,
+		findOne,
+	}
+}