@lucashw68/nsdb 1.0.0-rc.2

package/helpers/tables.js

@@ -0,0 +1,79 @@
+function normalizeTableList(value, optionName) {
+	if (value == null) return []
+	if (!Array.isArray(value) || value.some(table => typeof table !== 'string' || !table.trim())) {
+		throw new TypeError(`[nsdb] tables.${optionName} must be an array of non-empty table names.`)
+	}
+	return [...new Set(value.map(table => table.trim()))]
+}
+
+export function selectTableNames(availableTableNames, tableSelection = {}) {
+	const available = [...new Set(availableTableNames)].sort((left, right) => left.localeCompare(right))
+	const include = normalizeTableList(tableSelection?.include, 'include')
+	const exclude = normalizeTableList(tableSelection?.exclude, 'exclude')
+
+	if (include.length > 0 && exclude.length > 0) {
+		throw new Error('[nsdb] Configure either tables.include or tables.exclude, not both.')
+	}
+
+	const availableSet = new Set(available)
+	const configuredNames = include.length > 0 ? include : exclude
+	const unknownNames = configuredNames.filter(table => !availableSet.has(table))
+	if (unknownNames.length > 0) {
+		throw new Error(`[nsdb] Unknown table(s) in exposure config: ${unknownNames.join(', ')}`)
+	}
+
+	if (include.length > 0) {
+		const included = new Set(include)
+		return available.filter(table => included.has(table))
+	}
+
+	const excluded = new Set(exclude)
+	return available.filter(table => !excluded.has(table))
+}
+
+export function selectTableProperties(tablesType, tableSelection = {}) {
+	const properties = tablesType.getProperties()
+	const byName = new Map(properties.map(property => [property.getName(), property]))
+	return selectTableNames([...byName.keys()], tableSelection).map(tableName => byName.get(tableName))
+}
+
+export function getColumnPolicies(tableSelection = {}, tableName, availableColumnNames) {
+	const configuredTables = tableSelection?.columns ?? {}
+	if (configuredTables == null || typeof configuredTables !== 'object' || Array.isArray(configuredTables)) {
+		throw new TypeError('[nsdb] tables.columns must be an object keyed by table name.')
+	}
+
+	const tableRules = configuredTables[tableName] ?? {}
+	if (typeof tableRules !== 'object' || Array.isArray(tableRules)) {
+		throw new TypeError(`[nsdb] tables.columns.${tableName} must be an object keyed by column name.`)
+	}
+
+	const available = new Set(availableColumnNames)
+	const unknown = Object.keys(tableRules).filter(column => !available.has(column))
+	if (unknown.length) {
+		throw new Error(`[nsdb] Unknown column(s) for ${tableName}: ${unknown.join(', ')}`)
+	}
+
+	const result = {}
+	for (const columnName of availableColumnNames) {
+		const rule = tableRules[columnName] ?? {}
+		if (typeof rule !== 'object' || Array.isArray(rule)) {
+			throw new TypeError(`[nsdb] Column policy ${tableName}.${columnName} must be an object.`)
+		}
+		for (const key of ['selectable', 'editable', 'hidden', 'serverOnly']) {
+			if (rule[key] != null && typeof rule[key] !== 'boolean') {
+				throw new TypeError(`[nsdb] ${tableName}.${columnName}.${key} must be boolean.`)
+			}
+		}
+		if (rule.serverOnly && (rule.selectable === true || rule.editable === true)) {
+			throw new Error(`[nsdb] ${tableName}.${columnName} cannot be serverOnly and selectable/editable.`)
+		}
+		result[columnName] = {
+			selectable: rule.serverOnly ? false : rule.selectable ?? true,
+			editable: rule.serverOnly ? false : rule.editable,
+			hidden: rule.serverOnly ? true : rule.hidden ?? false,
+			serverOnly: rule.serverOnly ?? false,
+		}
+	}
+	return result
+}

package/helpers/ts.js

@@ -0,0 +1,37 @@
+// helpers/ts.js
+import { Project } from 'ts-morph'
+
+export function createTsProject() {
+	// Supabase's Row/Insert distinction depends on preserving `null` in unions.
+	// The in-memory generator project must not inherit TypeScript's loose default.
+	return new Project({
+		skipAddingFilesFromTsConfig: true,
+		compilerOptions: { strictNullChecks: true },
+	})
+}
+
+export function addSourceFile(project, absPath) {
+	return project.addSourceFileAtPath(absPath)
+}
+
+export function loadDatabaseAlias(sourceFile) {
+	try {
+		return sourceFile.getTypeAliasOrThrow('Database')
+	} catch {
+		return null
+	}
+}
+
+export function getPublicEnumsType(databaseAlias) {
+	const databaseType = databaseAlias.getType()
+	const publicType = databaseType.getProperty('public')?.getTypeAtLocation(databaseAlias)
+	if (!publicType) return null
+	return publicType.getProperty('Enums')?.getTypeAtLocation(databaseAlias) ?? null
+}
+
+export function getPublicTablesType(databaseAlias) {
+	const databaseType = databaseAlias.getType()
+	const publicType = databaseType.getProperty('public')?.getTypeAtLocation(databaseAlias)
+	if (!publicType) return null
+	return publicType.getProperty('Tables')?.getTypeAtLocation(databaseAlias) ?? null
+}

package/module.ts

@@ -0,0 +1,151 @@
+import {
+	defineNuxtModule,
+	addComponentsDir,
+	addImports,
+	addImportsDir,
+	addTemplate,
+	createResolver,
+	logger
+} from '@nuxt/kit'
+import { existsSync } from 'node:fs'
+
+export interface NsdbOptions {
+	withComponents?: boolean
+	componentsPrefix?: string
+	withStores?: boolean
+	autoImportModels?: boolean
+}
+
+export default defineNuxtModule<NsdbOptions>({
+	meta: { name: '@lucashw68/nsdb', configKey: 'nsdb' },
+	defaults: { withComponents: true, componentsPrefix: 'Nsdb', withStores: true, autoImportModels: true },
+
+	setup(options: NsdbOptions, nuxt: any) {
+		const { resolve } = createResolver(import.meta.url)
+		const rMod = createResolver(import.meta.url)
+		const rApp = createResolver(nuxt.options.rootDir)
+
+		const runtimeDir = rMod.resolve('./runtime')
+		// 1) Alias interne vers le runtime du module
+		nuxt.options.alias['#nsdb'] = runtimeDir
+
+		if (options.withComponents) {
+			addComponentsDir({
+				path: resolve(runtimeDir, 'components'),
+				prefix: options.componentsPrefix ?? 'Nsdb',
+				pathPrefix: false,
+				ignore: ['Form/**'],
+				transpile: true,
+			})
+		}
+
+		// 2) Proxies de build pour les barrels d'app:
+		//    -> import { ... } from '#build/nsdb/models'
+		//    -> import { ... } from '#build/nsdb/schemas'
+		const appModelsAbs = rApp.resolve('nsdb/models/index.ts')
+		const appSchemasAbs = rApp.resolve('nsdb/schemas/index.ts')
+		const appRegistryAbs = rApp.resolve('nsdb/composables/useNsdbModels.ts')
+		const appModelsExists = existsSync(appModelsAbs)
+		const appSchemasExists = existsSync(appSchemasAbs)
+		const appRegistryExists = existsSync(appRegistryAbs)
+
+		addTemplate({
+			filename: 'nsdb/models.ts',
+			write: true,
+			getContents: () =>
+				appModelsExists
+					? `export * from '~~/nsdb/models'`
+					: `// Fallback neutre: générez vos modules avec nsdb:models
+					export {}`
+		})
+
+		addTemplate({
+			filename: 'nsdb/schemas.ts',
+			write: true,
+			getContents: () =>
+				appSchemasExists
+					? `export * from '~~/nsdb/schemas'`
+					: `// Fallback neutre: générez vos schémas avec nsdb:models (qui émet aussi nsdb/schemas)
+					export {}`
+		})
+
+		addTemplate({
+			filename: 'nsdb/registry.ts',
+			write: true,
+			getContents: () =>
+				appRegistryExists
+					? `export { useNsdbModel } from '~~/nsdb/composables/useNsdbModels'`
+					: `export function useNsdbModel(model: string): never {
+						throw new Error('[nsdb] No generated model registry found for "' + model + '". Run nsdb generate:all.')
+					}`
+		})
+
+		// Regénère les proxies si ~/nsdb/models.ts ou ~/nsdb/schemas.ts apparaissent en dev
+		nuxt.hook('builder:watch', (_event: string, relPath: string) => {
+			if (!relPath) return
+			const normalized = relPath.replace(/^[./]+/, '')
+			if (normalized === 'nsdb/models/index.ts') {
+				addTemplate({
+					filename: 'nsdb/models.ts',
+					write: true,
+					getContents: () => `export * from '~~/nsdb/models'`
+				})
+				logger.success('[nsdb] Proxy #build/nsdb/models mis à jour (~/nsdb/models.ts détecté).')
+			}
+			if (normalized === 'nsdb/schemas/index.ts') {
+				addTemplate({
+					filename: 'nsdb/schemas.ts',
+					write: true,
+					getContents: () => `export * from '~~/nsdb/schemas'`
+				})
+				logger.success('[nsdb] Proxy #build/nsdb/schemas mis à jour (~/nsdb/schemas.ts détecté).')
+			}
+			if (normalized === 'nsdb/composables/useNsdbModels.ts') {
+				addTemplate({
+					filename: 'nsdb/registry.ts',
+					write: true,
+					getContents: () => `export { useNsdbModel } from '~~/nsdb/composables/useNsdbModels'`
+				})
+				logger.success('[nsdb] Proxy #build/nsdb/registry mis à jour.')
+			}
+		})
+
+		// 3) Public runtime auto-imports. Keep this list explicit: exporting a
+		// helper from a runtime file must not accidentally make it app-global.
+		addImports([
+			{ name: 'useSupabaseApi', from: rMod.resolve(runtimeDir, 'composables/useSupabaseApi') },
+			{ name: 'useSupabaseApiStorage', from: rMod.resolve(runtimeDir, 'composables/useSupabaseApiStorage') },
+			{ name: 'useSupabaseModel', from: rMod.resolve(runtimeDir, 'composables/useSupabaseModels') },
+			{ name: 'useNsdbSchema', from: rMod.resolve(runtimeDir, 'composables/useNsdbSchemas') },
+			{ name: 'useNsdbProfile', from: rMod.resolve(runtimeDir, 'composables/useNsdbProfile') },
+		])
+		if (options.withStores) {
+			addImports([
+				{ name: 'createDbStore', from: rMod.resolve(runtimeDir, 'stores/createDbStore') },
+				{ name: 'createSingletonStore', from: rMod.resolve(runtimeDir, 'stores/createSingletonDbStore') },
+			])
+		}
+		if (appModelsExists && options.autoImportModels) {
+			const generatedModelsDir = rApp.resolve('nsdb/models')
+			addImportsDir(generatedModelsDir)
+			nuxt.hook('imports:extend', (imports: Array<{ name?: string; as?: string; from?: string }>) => {
+				const generatedImports = imports.filter(entry => entry.from?.startsWith(generatedModelsDir))
+				for (const generatedImport of generatedImports) {
+					const publicName = generatedImport.as ?? generatedImport.name
+					if (!publicName?.startsWith('use')) continue
+					const collision = imports.find(entry =>
+						entry !== generatedImport &&
+						(entry.as ?? entry.name) === publicName &&
+						!entry.from?.startsWith(generatedModelsDir),
+					)
+						if (collision) {
+						throw new Error(
+							`[nsdb] Auto-import collision for "${publicName}" between generated models and ${collision.from}. ` +
+							'Set nsdb.autoImportModels=false and import the generated model explicitly.',
+							)
+						}
+					}
+				})
+		}
+	}
+})

package/nsdb.config.example.mjs

@@ -0,0 +1,39 @@
+export default {
+	supabase: {
+		schema: 'public',
+		projectId: process.env.SUPABASE_PROJECT_ID,
+		// For self-hosted Supabase, use dbUrl instead of projectId:
+		// dbUrl: process.env.SUPABASE_DB_URL,
+		// If Postgres is only reachable from a VPS, generate types remotely:
+		// remoteTypes: {
+		// 	sshHost: process.env.SUPABASE_REMOTE_SSH_HOST,
+		// 	projectPath: process.env.SUPABASE_REMOTE_PROJECT_PATH,
+		// 	dbUrl: process.env.SUPABASE_REMOTE_DB_URL,
+		// 	remoteOutput: '/tmp/database.types.ts',
+		// 	beforeCommand: process.env.SUPABASE_REMOTE_BEFORE_COMMAND,
+		// 	supabaseCommand: process.env.SUPABASE_REMOTE_SUPABASE_COMMAND,
+		// },
+		linked: false,
+	},
+	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',
+	},
+	imports: {
+		databaseTypes: '~~/types/database.types',
+	},
+	tables: {
+		include: ['playlists'],
+		columns: {
+			playlists: {
+				internal_note: { serverOnly: true },
+				created_at: { editable: false },
+			},
+		},
+	},
+}

package/nsdb.config.example.ts

@@ -0,0 +1,42 @@
+import type { NsdbConfig } from '@lucashw68/nsdb/types/config'
+
+export default {
+	supabase: {
+		schema: 'public',
+		projectId: process.env.SUPABASE_PROJECT_ID,
+		// For self-hosted Supabase, use dbUrl instead of projectId:
+		// dbUrl: process.env.SUPABASE_DB_URL,
+		// If Postgres is only reachable from a VPS, generate types remotely:
+		// remoteTypes: {
+		// 	sshHost: process.env.SUPABASE_REMOTE_SSH_HOST,
+		// 	projectPath: process.env.SUPABASE_REMOTE_PROJECT_PATH,
+		// 	dbUrl: process.env.SUPABASE_REMOTE_DB_URL,
+		// 	remoteOutput: '/tmp/database.types.ts',
+		// 	beforeCommand: process.env.SUPABASE_REMOTE_BEFORE_COMMAND,
+		// 	supabaseCommand: process.env.SUPABASE_REMOTE_SUPABASE_COMMAND,
+		// },
+		linked: false,
+	},
+	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',
+	},
+	imports: {
+		databaseTypes: '~~/types/database.types',
+	},
+	tables: {
+		// Prefer an allowlist for browser-facing artifacts.
+		include: ['playlists'],
+		columns: {
+			playlists: {
+				internal_note: { serverOnly: true },
+				created_at: { editable: false },
+			},
+		},
+	},
+} satisfies NsdbConfig

package/package.json

@@ -0,0 +1,114 @@
+{
+	"name": "@lucashw68/nsdb",
+	"version": "1.0.0-rc.2",
+	"type": "module",
+	"description": "A typed Nuxt 4 bridge for Supabase models, optional Pinia caching and generic CRUD components.",
+	"license": "MIT",
+	"keywords": [
+		"nuxt",
+		"supabase",
+		"pinia",
+		"store",
+		"module",
+		"database",
+		"layer"
+	],
+	"engines": {
+		"node": ">=22.14.0"
+	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org/",
+		"tag": "next"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Lucashw68/nsdb.git",
+		"directory": "Nsdb"
+	},
+	"homepage": "https://github.com/Lucashw68/nsdb#readme",
+	"bugs": {
+		"url": "https://github.com/Lucashw68/nsdb/issues"
+	},
+	"exports": {
+		".": "./module.ts",
+		"./useSupabaseApi": "./runtime/composables/useSupabaseApi.ts",
+		"./useSupabaseApiStorage": "./runtime/composables/useSupabaseApiStorage.ts",
+		"./useSupabaseModel": "./runtime/composables/useSupabaseModels.ts",
+		"./useNsdbProfile": "./runtime/composables/useNsdbProfile.ts",
+		"./useNsdbSchema": "./runtime/composables/useNsdbSchemas.ts",
+		"./types": "./types/index.ts",
+		"./types/config": "./types/config.ts",
+		"./types/entities": "./types/entities.ts",
+		"./types/list": "./types/list.ts",
+		"./types/model": "./types/model.ts",
+		"./createDbStore": "./runtime/stores/createDbStore.ts",
+		"./createSingletonStore": "./runtime/stores/createSingletonDbStore.ts"
+	},
+	"dependencies": {
+		"@nuxt/kit": "^4.0.1",
+		"@supabase/supabase-js": "^2.56.0",
+		"@types/node": "^22.0.0",
+		"postgres": "3.4.7",
+		"ts-morph": "^20.0.0",
+		"tsx": "^4.20.5"
+	},
+	"devDependencies": {
+		"@nuxt/kit": "^4.0.1",
+		"@vitejs/plugin-vue": "6.0.1",
+		"@vue/test-utils": "2.4.6",
+		"happy-dom": "18.0.1",
+		"pinia": "^3.0.3",
+		"typescript": "^5.0.0",
+		"vitest": "3.2.4",
+		"vue": "3.5.24"
+	},
+	"peerDependencies": {
+		"@nuxtjs/supabase": "^1.6.1 || ^2.0.0",
+		"@pinia/nuxt": "^0.11.2",
+		"nuxt": "^4.2.1",
+		"pinia": "^3.0.3",
+		"pinia-plugin-persistedstate": "^4.5.0",
+		"vue": "^3.5.24"
+	},
+	"peerDependenciesMeta": {
+		"pinia-plugin-persistedstate": {
+			"optional": true
+		}
+	},
+	"bin": {
+		"nsdb": "./cli/index.js"
+	},
+	"scripts": {
+		"generate:types": "node ./scripts/generate-types.js",
+		"generate:metadata": "node ./scripts/generate-metadata.js",
+		"generate:enums": "node ./scripts/generate-enums.js",
+		"generate:schemas": "node ./scripts/generate-schemas.js",
+		"generate:models": "node ./scripts/generate-models.js",
+		"generate:composables": "node ./scripts/generate-composables.js",
+		"generate:stores": "node ./scripts/generate-stores.js",
+		"generate:all": "npm run generate:types && npm run generate:metadata && npm run generate:enums && npm run generate:schemas && npm run generate:models && npm run generate:stores && npm run generate:models && npm run generate:composables",
+		"typecheck": "tsc --noEmit",
+		"check": "tsc --noEmit",
+		"test": "npm run test:node && npm run test:runtime",
+		"test:node": "node --test \"tests/**/*.test.mjs\"",
+		"test:runtime": "vitest run",
+		"test:consumer": "node tests/fresh-consumer.mjs",
+		"prepublishOnly": "npm run check && npm test",
+		"clear": "node scripts/clear.js"
+	},
+	"files": [
+		"CHANGELOG.md",
+		"GET_STARTED.md",
+		"module.ts",
+		"runtime",
+		"scripts",
+		"templates",
+		"helpers",
+		"cli",
+		"types",
+		"nsdb.config.example.ts",
+		"nsdb.config.example.mjs"
+	],
+	"packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}