@lucashw68/nsdb 1.0.0-rc.2

package/scripts/generate-types.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import path from 'path'
+import { parseArgs } from '../helpers/args.js'
+import { ensureDir, readText, writeText } from '../helpers/io.js'
+import { run, isAvailable } from '../helpers/shell.js'
+import { getBoolOption, getOption, loadNsdbConfig } from '../helpers/config.js'
+
+/**
+ * Build the Supabase CLI command that dumps the database types to disk.
+ */
+function quoteShellArgument(value) {
+	return `'${String(value).replaceAll("'", "'\\''")}'`
+}
+
+function quoteRemoteShellArgument(value) {
+	return `"${String(value)
+		.replaceAll('\\', '\\\\')
+		.replaceAll('"', '\\"')
+		.replaceAll('`', '\\`')}"`
+}
+
+export function buildCommand({
+	projectId,
+	dbUrl,
+	outputPath,
+	schemaName,
+	useLinkedProject,
+	supabaseCommand = 'npx supabase',
+	argumentQuoter = quoteShellArgument,
+}) {
+	const parts = [`${supabaseCommand} gen types typescript`]
+	if (schemaName) parts.push(`--schema ${schemaName}`)
+	if (dbUrl) {
+		parts.push(`--db-url ${argumentQuoter(dbUrl)}`)
+	} else {
+		parts.push(useLinkedProject ? '--linked' : `--project-id ${projectId}`)
+	}
+	parts.push(`> ${argumentQuoter(outputPath)}`)
+	return parts.join(' ')
+}
+
+export function buildLocalTypesEnvironment({ dbUrl, environment = process.env }) {
+	const commandEnvironment = { ...environment }
+	if (dbUrl) delete commandEnvironment.SUPABASE_PROJECT_ID
+	return commandEnvironment
+}
+
+export function buildRemoteTypesCommands({
+	sshHost,
+	projectPath,
+	dbUrl,
+	remoteOutput = '/tmp/database.types.ts',
+	localOutputPath,
+	schemaName = 'public',
+	beforeCommand = '',
+	supabaseCommand = 'npx supabase',
+}) {
+	const remoteGenerateCommand = [
+		projectPath ? `cd ${quoteShellArgument(projectPath)}` : '',
+		beforeCommand,
+		buildCommand({
+			dbUrl,
+			outputPath: remoteOutput,
+			schemaName,
+			useLinkedProject: false,
+			supabaseCommand,
+			argumentQuoter: quoteRemoteShellArgument,
+		}),
+	]
+		.filter(Boolean)
+		.join(' && ')
+
+	return {
+		generateCommand: `ssh ${quoteShellArgument(sshHost)} ${quoteShellArgument(remoteGenerateCommand)}`,
+		copyCommand: `scp ${quoteShellArgument(`${sshHost}:${remoteOutput}`)} ${quoteShellArgument(localOutputPath)}`,
+	}
+}
+
+async function loadDotenvIfAvailable(dotenvFilePath) {
+	try {
+		const dotenvModule = await import('dotenv')
+		dotenvModule.config({ path: dotenvFilePath })
+	} catch (error) {
+		const errorCode = error?.code || error?.cause?.code
+		if (errorCode !== 'ERR_MODULE_NOT_FOUND') {
+			console.warn(`⚠️  Unable to load dotenv file at ${dotenvFilePath}:`, error?.message || error)
+		}
+	}
+}
+
+function normalizeGeneratedTypes(filePath) {
+	writeText(filePath, `${readText(filePath).trimEnd()}\n`)
+}
+
+async function main() {
+	const parsedArguments = parseArgs()
+	const currentWorkingDirectory = process.cwd()
+	const { config } = await loadNsdbConfig(currentWorkingDirectory, parsedArguments.get('config', ''))
+	const dotenvFilePath = path.resolve(currentWorkingDirectory, parsedArguments.get('dotenv', '.env'))
+	await loadDotenvIfAvailable(dotenvFilePath)
+
+	const outputFilePath = path.resolve(currentWorkingDirectory, getOption(parsedArguments, config, 'out', 'paths.types'))
+	const projectId = getOption(parsedArguments, config, 'project-id', 'supabase.projectId', process.env.SUPABASE_PROJECT_ID || '')
+	const dbUrl = getOption(parsedArguments, config, 'db-url', 'supabase.dbUrl', process.env.SUPABASE_DB_URL || '')
+	const schemaName = getOption(parsedArguments, config, 'schema', 'supabase.schema', 'public')
+	const useLinkedProject = getBoolOption(parsedArguments, config, 'linked', 'supabase.linked', false)
+	const remoteSshHost = getOption(parsedArguments, config, 'remote-ssh-host', 'supabase.remoteTypes.sshHost', process.env.SUPABASE_REMOTE_SSH_HOST || '')
+	const remoteProjectPath = getOption(parsedArguments, config, 'remote-project-path', 'supabase.remoteTypes.projectPath', process.env.SUPABASE_REMOTE_PROJECT_PATH || '')
+	const remoteDbUrl = getOption(parsedArguments, config, 'remote-db-url', 'supabase.remoteTypes.dbUrl', process.env.SUPABASE_REMOTE_DB_URL || '')
+	const remoteOutputPath = getOption(parsedArguments, config, 'remote-output', 'supabase.remoteTypes.remoteOutput', '/tmp/database.types.ts')
+	const remoteBeforeCommand = getOption(parsedArguments, config, 'remote-before-command', 'supabase.remoteTypes.beforeCommand', process.env.SUPABASE_REMOTE_BEFORE_COMMAND || '')
+	const remoteSupabaseCommand = getOption(parsedArguments, config, 'remote-supabase-command', 'supabase.remoteTypes.supabaseCommand', process.env.SUPABASE_REMOTE_SUPABASE_COMMAND || 'npx supabase')
+	const useRemoteTypes = Boolean(remoteSshHost)
+
+	if (useRemoteTypes && !remoteDbUrl) {
+		console.error('❌ Missing remote DB URL (pass --remote-db-url or set supabase.remoteTypes.dbUrl).')
+		process.exit(1)
+	}
+
+	if (!useRemoteTypes && !dbUrl && !useLinkedProject && !projectId) {
+		console.error('❌ Missing Supabase source (pass --remote-ssh-host, --db-url, --project-id or --linked).')
+		process.exit(1)
+	}
+
+	if (!useRemoteTypes && !isAvailable('npx supabase --version')) {
+		console.error('❌ Supabase CLI not available. Install it with: npm i -D supabase')
+		process.exit(1)
+	}
+
+	ensureDir(path.dirname(outputFilePath))
+	if (useRemoteTypes) {
+		const { generateCommand, copyCommand } = buildRemoteTypesCommands({
+			sshHost: remoteSshHost,
+			projectPath: remoteProjectPath,
+			dbUrl: remoteDbUrl,
+			remoteOutput: remoteOutputPath,
+			localOutputPath: outputFilePath,
+			schemaName,
+			beforeCommand: remoteBeforeCommand,
+			supabaseCommand: remoteSupabaseCommand,
+		})
+
+		console.log(`📦 Project: ${remoteSshHost} (remote ssh)`)
+		console.log(`📁 Output: ${path.relative(currentWorkingDirectory, outputFilePath)}`)
+		console.log(`📚 Schema: ${schemaName}`)
+		console.log(`🗄️  Remote output: ${remoteOutputPath}`)
+		console.log('🔄 Generating Supabase types remotely...')
+
+		try {
+			run(generateCommand, { inherit: true })
+			run(copyCommand, { inherit: true })
+			normalizeGeneratedTypes(outputFilePath)
+			console.log('✅ Types generated and copied successfully.')
+		} catch (error) {
+			console.error('❌ Failed to generate Supabase types remotely.')
+			process.exit(1)
+		}
+
+		return
+	}
+
+	const commandLine = buildCommand({
+		projectId,
+		dbUrl,
+		outputPath: outputFilePath,
+		schemaName,
+		useLinkedProject
+	})
+
+	console.log(`📦 Project: ${dbUrl ? '(db-url)' : useLinkedProject ? '(linked)' : projectId}`)
+	console.log(`📁 Output: ${path.relative(currentWorkingDirectory, outputFilePath)}`)
+	console.log(`📚 Schema: ${schemaName}`)
+	if (dbUrl) console.log('🗄️  DB URL mode enabled')
+	if (useLinkedProject) console.log('🔗 Linked project mode enabled')
+	console.log('🔄 Generating Supabase types...')
+
+	try {
+		run(commandLine, {
+			inherit: true,
+			env: buildLocalTypesEnvironment({ dbUrl }),
+		})
+		normalizeGeneratedTypes(outputFilePath)
+		console.log('✅ Types generated successfully.')
+	} catch (error) {
+		console.error('❌ Failed to generate Supabase types.')
+		process.exit(1)
+	}
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	main().catch((error) => {
+		console.error('❌ Unexpected error while generating types.')
+		console.error(error)
+		process.exit(1)
+	})
+}

package/scripts/init.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import path from 'node:path'
+import { parseArgs } from '../helpers/args.js'
+import { ensureDir, exists, readText, writeText } from '../helpers/io.js'
+
+const DEFAULT_PATHS = {
+	types: 'types/database.types.ts',
+	metadata: 'nsdb/database.metadata.json',
+	enums: 'nsdb/enums.ts',
+	schemas: 'nsdb/schemas',
+	models: 'nsdb/models',
+	composables: 'nsdb/composables',
+	stores: 'stores',
+}
+
+const NSDB_SCRIPTS = {
+	'nsdb:init': 'nsdb init',
+	'nsdb:types': 'nsdb generate:types',
+	'nsdb:metadata': 'nsdb generate:metadata',
+	'nsdb:enums': 'nsdb generate:enums',
+	'nsdb:schemas': 'nsdb generate:schemas',
+	'nsdb:models': 'nsdb generate:models',
+	'nsdb:composables': 'nsdb generate:composables',
+	'nsdb:stores': 'nsdb generate:stores',
+	'nsdb:all': 'nsdb generate:all',
+}
+
+function quoteString(value) {
+	return `'${String(value).replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`
+}
+
+export function buildNsdbConfigTemplate({
+	schemaName = 'public',
+	projectIdExpression = 'process.env.SUPABASE_PROJECT_ID',
+	dbUrlExpression = '',
+	remoteTypes = null,
+	linked = false,
+	paths = DEFAULT_PATHS,
+} = {}) {
+	const usesDefaultPaths = Object.entries(DEFAULT_PATHS).every(([key, value]) => paths[key] === value)
+	const projectIdLine = linked || dbUrlExpression || remoteTypes
+		? ''
+		: `\n\t\tprojectId: ${projectIdExpression},`
+	const dbUrlLine = dbUrlExpression
+		? `\n\t\tdbUrl: ${dbUrlExpression},`
+		: ''
+	const remoteTypesLine = remoteTypes
+		? `\n\t\tremoteTypes: {
+\t\t\tsshHost: ${remoteTypes.sshHost},
+\t\t\tprojectPath: ${remoteTypes.projectPath},
+\t\t\tdbUrl: ${remoteTypes.dbUrl},
+\t\t\tremoteOutput: ${remoteTypes.remoteOutput},
+\t\t\tbeforeCommand: ${remoteTypes.beforeCommand},
+\t\t\tsupabaseCommand: ${remoteTypes.supabaseCommand},
+\t\t},`
+		: ''
+	const pathsBlock = usesDefaultPaths
+		? ''
+		: `
+	paths: {
+${Object.entries(paths).map(([key, value]) => `\t\t${key}: ${quoteString(value)},`).join('\n')}
+	},
+	imports: {
+		databaseTypes: '~~/types/database.types',
+	},`
+
+	return `import type { NsdbConfig } from '@lucashw68/nsdb/types/config'
+
+export default {
+\tsupabase: {
+\t\tschema: ${quoteString(schemaName)},${projectIdLine}${dbUrlLine}${remoteTypesLine}
+\t\tlinked: ${linked ? 'true' : 'false'},
+\t},${pathsBlock}
+} satisfies NsdbConfig
+`
+}
+
+export function mergePackageScripts(packageJson, scriptsToAdd = NSDB_SCRIPTS) {
+	const nextPackageJson = {
+		...packageJson,
+		scripts: {
+			...(packageJson.scripts ?? {}),
+		},
+	}
+
+	for (const [scriptName, scriptCommand] of Object.entries(scriptsToAdd)) {
+		if (!nextPackageJson.scripts[scriptName]) {
+			nextPackageJson.scripts[scriptName] = scriptCommand
+		}
+	}
+
+	return nextPackageJson
+}
+
+function buildEnvExample() {
+	return `SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-anon-key
+SUPABASE_PROJECT_ID=your-project-id
+SUPABASE_DB_URL=postgresql://postgres:password@localhost:5432/postgres
+SUPABASE_REMOTE_SSH_HOST=vps
+SUPABASE_REMOTE_PROJECT_PATH=/opt/supabase-projects/example
+SUPABASE_REMOTE_DB_URL=postgresql://postgres:$POSTGRES_PASSWORD@db:5432/postgres
+SUPABASE_REMOTE_BEFORE_COMMAND=source ~/.nvm/nvm.sh
+SUPABASE_REMOTE_SUPABASE_COMMAND=npx supabase
+`
+}
+
+function writeFileIfAllowed(filePath, content, { force = false, label }) {
+	if (exists(filePath) && !force) {
+		console.log(`↷ ${label} already exists, skipped: ${path.relative(process.cwd(), filePath)}`)
+		return false
+	}
+
+	writeText(filePath, content)
+	console.log(`✓ ${label}: ${path.relative(process.cwd(), filePath)}`)
+	return true
+}
+
+function ensureConfiguredDirectories(currentWorkingDirectory, paths = DEFAULT_PATHS) {
+	const directories = [
+		path.dirname(paths.types),
+		path.dirname(paths.metadata),
+		path.dirname(paths.enums),
+		paths.schemas,
+		paths.models,
+		paths.composables,
+		paths.stores,
+	]
+
+	for (const directoryPath of directories) {
+		const absoluteDirectoryPath = path.resolve(currentWorkingDirectory, directoryPath)
+		ensureDir(absoluteDirectoryPath)
+		console.log(`✓ Directory: ${path.relative(currentWorkingDirectory, absoluteDirectoryPath)}`)
+	}
+}
+
+function updatePackageJson(currentWorkingDirectory) {
+	const packageJsonPath = path.resolve(currentWorkingDirectory, 'package.json')
+
+	if (!exists(packageJsonPath)) {
+		console.log('↷ package.json not found, skipped scripts setup')
+		return false
+	}
+
+	const packageJson = JSON.parse(readText(packageJsonPath))
+	const nextPackageJson = mergePackageScripts(packageJson)
+	writeText(packageJsonPath, `${JSON.stringify(nextPackageJson, null, 2)}\n`)
+	console.log('✓ package.json scripts')
+	return true
+}
+
+function printNextSteps({ linked, usesDbUrl }) {
+	console.log('')
+	console.log('Next steps:')
+	console.log('1. Add @lucashw68/nsdb to modules in nuxt.config.ts.')
+	console.log('2. Configure @nuxtjs/supabase with SUPABASE_URL and SUPABASE_KEY.')
+	if (!linked && !usesDbUrl) console.log('3. Set SUPABASE_PROJECT_ID in .env.')
+	if (usesDbUrl) console.log('3. Set SUPABASE_DB_URL or SUPABASE_REMOTE_* variables in .env.')
+	console.log(`${linked && !usesDbUrl ? '3' : '4'}. Run: npm run nsdb:all`)
+}
+
+export async function initNsdb({
+	currentWorkingDirectory = process.cwd(),
+	parsedArguments = parseArgs(),
+} = {}) {
+	const force = parsedArguments.getBool('force', false)
+	const linked = parsedArguments.getBool('linked', false)
+	const schemaName = parsedArguments.get('schema', 'public')
+	const projectId = parsedArguments.get('project-id', '')
+	const dbUrl = parsedArguments.get('db-url', '')
+	const remoteSshHost = parsedArguments.get('remote-ssh-host', '')
+	const remoteProjectPath = parsedArguments.get('remote-project-path', '')
+	const remoteDbUrl = parsedArguments.get('remote-db-url', '')
+	const remoteOutput = parsedArguments.get('remote-output', '/tmp/database.types.ts')
+	const remoteBeforeCommand = parsedArguments.get('remote-before-command', '')
+	const remoteSupabaseCommand = parsedArguments.get('remote-supabase-command', '')
+	const projectIdExpression = projectId ? quoteString(projectId) : 'process.env.SUPABASE_PROJECT_ID'
+	const dbUrlExpression = dbUrl ? quoteString(dbUrl) : parsedArguments.getBool('self-hosted', false) ? 'process.env.SUPABASE_DB_URL' : ''
+	const useRemoteTypes = Boolean(remoteSshHost) || parsedArguments.getBool('remote-types', false)
+	const remoteTypes = useRemoteTypes
+		? {
+			sshHost: remoteSshHost ? quoteString(remoteSshHost) : 'process.env.SUPABASE_REMOTE_SSH_HOST',
+			projectPath: remoteProjectPath ? quoteString(remoteProjectPath) : 'process.env.SUPABASE_REMOTE_PROJECT_PATH',
+			dbUrl: remoteDbUrl ? quoteString(remoteDbUrl) : 'process.env.SUPABASE_REMOTE_DB_URL',
+			remoteOutput: quoteString(remoteOutput),
+			beforeCommand: remoteBeforeCommand ? quoteString(remoteBeforeCommand) : 'process.env.SUPABASE_REMOTE_BEFORE_COMMAND',
+			supabaseCommand: remoteSupabaseCommand ? quoteString(remoteSupabaseCommand) : 'process.env.SUPABASE_REMOTE_SUPABASE_COMMAND',
+		}
+		: null
+	const configFileName = parsedArguments.get('config', 'nsdb.config.ts')
+	const configFilePath = path.resolve(currentWorkingDirectory, configFileName)
+	const envExampleFilePath = path.resolve(currentWorkingDirectory, '.env.example')
+
+	console.log('🧬 Initializing NSDB...')
+
+	writeFileIfAllowed(
+		configFilePath,
+		buildNsdbConfigTemplate({
+			schemaName,
+			projectIdExpression,
+			dbUrlExpression,
+			remoteTypes,
+			linked,
+			paths: DEFAULT_PATHS,
+		}),
+		{ force, label: 'Config' }
+	)
+
+	writeFileIfAllowed(envExampleFilePath, buildEnvExample(), {
+		force: false,
+		label: 'Env example',
+	})
+
+	ensureConfiguredDirectories(currentWorkingDirectory, DEFAULT_PATHS)
+	updatePackageJson(currentWorkingDirectory)
+	printNextSteps({ linked, usesDbUrl: Boolean(dbUrlExpression || remoteTypes) })
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	initNsdb().catch((error) => {
+		console.error('❌ Failed to initialize NSDB.')
+		console.error(error)
+		process.exit(1)
+	})
+}

package/templates/model.template.ts

@@ -0,0 +1,48 @@
+// __IMPORTS__
+import type { Tables, TablesInsert, TablesUpdate } from '~~/types/database.types'
+import { __PASCAL__Relations, __PASCAL__Schema } from '~~/nsdb/schemas/__TABLE__'
+import { useNsdbSchema } from '@lucashw68/nsdb/useNsdbSchema'
+__STORE_IMPORT__
+
+export type __ROW__ = Omit<Tables<'__TABLE__'>, __ROW_OMIT__>
+export type __PASCAL__Insert = Omit<TablesInsert<'__TABLE__'>, __INSERT_OMIT__>
+export type __PASCAL__Update = Omit<TablesUpdate<'__TABLE__'>, __UPDATE_OMIT__>
+export type __PASCAL__RelationRows = __RELATION_ROWS__
+
+export function __HOOK__(opts: { store?: boolean } = {}) {
+	const model = useSupabaseModel<__ROW__, __PASCAL__Insert, __PASCAL__Update, '__PRIMARY_KEY__'>(
+		'__TABLE__',
+		{ store: !!opts.store, storeCreator: __STORE_CREATOR__, primaryKey: '__PRIMARY_KEY__' }
+	)
+
+	const {
+		fields,
+		editableKeys,
+		createDraftFromSchema,
+		bindModel,
+	} = useNsdbSchema(__PASCAL__Schema, __PASCAL__Relations);
+
+	const { fetch, refresh } = bindModel<__ROW__, __PASCAL__RelationRows>(model)
+
+	return {
+		primaryKey: '__PRIMARY_KEY__' as const,
+		items: model.items,
+		totalCount: model.totalCount,
+		loading: model.loading,
+		error: model.error,
+		stale: model.stale,
+		schema: __PASCAL__Schema,
+		fields,
+		editableKeys,
+		createDraft: () => createDraftFromSchema(),
+		fetch,
+		refresh,
+		invalidate: model.invalidate,
+		getById: model.getById,
+		create: model.create,
+		update: model.update,
+		remove: model.remove,
+		subscribe: model.subscribe,
+		unsubscribe: model.unsubscribe,
+	}
+}

package/templates/schema.template.ts

@@ -0,0 +1,13 @@
+import type { Tables } from '~~/types/database.types'
+import type { EntityField, EntityRelation } from '@lucashw68/nsdb/types/entities'
+import * as Enums from '~~/nsdb/enums'
+
+// Convenience row type for this table (optional)
+export type __ROW__ = Tables<'__TABLE__'>
+
+/** ----- Schema (entities) for __TABLE__ ----- */
+export const __PASCAL__Schema = {
+// __FIELDS__
+} as const satisfies Partial<Record<keyof __ROW__, EntityField>>
+
+export const __PASCAL__Relations: EntityRelation[] = __RELATIONS__

package/templates/useNsdbModel.template.ts

@@ -0,0 +1,9 @@
+// __IMPORTS__
+
+export function useNsdbModel(model: string, opts: { store?: boolean } = {}) {
+	switch (model) {
+		// __CASES__
+		default:
+			throw new Error(`Aucun model nsdb enregistré pour le modèle "${model}"`)
+	}
+}

package/types/config.ts

@@ -0,0 +1,50 @@
+export interface NsdbConfig {
+	supabase?: {
+		schema?: string
+		projectId?: string
+		dbUrl?: string
+		linked?: boolean
+		remoteTypes?: {
+			sshHost?: string
+			projectPath?: string
+			dbUrl?: string
+			remoteOutput?: string
+			beforeCommand?: string
+			supabaseCommand?: string
+		}
+	}
+	paths?: {
+		types?: string
+		metadata?: string
+		enums?: string
+		schemas?: string
+		models?: string
+		composables?: string
+		stores?: string
+	}
+	imports?: {
+		databaseTypes?: string
+	}
+	tables?: {
+		/** Allowlist of tables exposed through generated NSDB artifacts. */
+		include?: string[]
+		/** Tables omitted from generated NSDB artifacts. Mutually exclusive with include. */
+		exclude?: string[]
+		/** Per-table client exposure rules. Unspecified columns keep inferred defaults. */
+		columns?: Record<string, Record<string, {
+			selectable?: boolean
+			editable?: boolean
+			hidden?: boolean
+			serverOnly?: boolean
+		}>>
+	}
+	templates?: {
+		model?: string
+		schema?: string
+		useNsdbModel?: string
+		store?: string
+	}
+	generators?: {
+		force?: boolean
+	}
+}

package/types/entities.ts

@@ -0,0 +1,66 @@
+export type FieldType =
+	| 'text'
+	| 'textarea'
+	| 'select'
+	| 'checkbox'
+	| 'number'
+	| 'date'
+	| 'datetime'
+	| 'json'
+	| 'array'
+	| 'file'
+	| 'relation'
+
+export type EntityField = {
+	label: string
+	type: FieldType
+	required?: boolean
+	readonly?: boolean
+	selectable?: boolean
+	editable?: boolean
+	insertable?: boolean
+	updatable?: boolean
+	hidden?: boolean
+	serverOnly?: boolean
+	primaryKey?: boolean
+	nullable?: boolean
+	hasDefault?: boolean
+	databaseType?: string
+	defaultExpression?: string | null
+	default?: any
+	options?: Array<{ label: string; value: any }>
+	relation?: EntityRelation
+}
+
+export type RelationKind = 'belongsTo' | 'hasOne' | 'hasMany' | 'manyToMany'
+
+export interface EntityRelation {
+	alias?: string
+	kind: RelationKind
+	direction?: 'forward' | 'inverse' | 'through'
+	nullable?: boolean
+	composite?: boolean
+	throughTable?: string
+	/** Table référencée dans Supabase (ex: "playlists") */
+	referencedTable: string
+	embedResource?: string
+	/** Colonnes locales qui forment la FK (souvent ["playlist_id"]) */
+	localColumns: string[]
+	/** Colonnes référencées (souvent ["id"]) */
+	referencedColumns: string[]
+	/** Nom de la FK dans Supabase (facultatif, pour debug) */
+	foreignKeyName?: string,
+
+	/**
+	 * Champ de la table référencée à utiliser comme label.
+	 * Exemple: "title", "username", "full_name", etc.
+	 * Si non fourni, on tombera sur 'id' (sans guess "intelligent").
+	 */
+	displayField?: string
+
+	/**
+	 * Est-ce qu'on autorise la création inline de l'entité liée
+	 * dans NsdbForm ? (préparation pour la suite)
+	 */
+	allowInlineCreate?: boolean
+}

package/types/index.ts

@@ -0,0 +1,14 @@
+export type { NsdbConfig } from './config'
+export type { EntityField, EntityRelation, FieldType, RelationKind } from './entities'
+export type {
+	Column,
+	ListOptions,
+	NsdbTableClasses,
+	OrderDirection,
+	SortState,
+	WhereClause,
+	WhereOperator,
+	WherePrimitive,
+	WhereValue,
+} from './list'
+export type { ModelHandle, ModelMutationTarget, ModelQuery, ModelWhere } from './model'