@toiroakr/lines-db 0.6.1 → 0.7.0

package/dist/index.js

@@ -159,6 +159,71 @@ var JsonlWriter = class {
 	}
 };
 
+//#endregion
+//#region src/schema-extensions.ts
+/**
+* Supported schema file extensions, in priority order.
+* The first match wins when discovering schema files.
+*/
+const SCHEMA_EXTENSIONS = [
+	".schema.ts",
+	".schema.mts",
+	".schema.cts"
+];
+/**
+* Map from schema extensions to their JavaScript import counterparts.
+*/
+const SCHEMA_TO_JS_IMPORT_MAP = {
+	".schema.ts": ".schema.js",
+	".schema.mts": ".schema.mjs",
+	".schema.cts": ".schema.cjs"
+};
+/**
+* Try each supported schema extension and return the full path of the first
+* one that exists on disk. Returns undefined if none is found.
+*/
+async function findSchemaFile(dir, tableName) {
+	for (const ext of SCHEMA_EXTENSIONS) {
+		const candidate = join(dir, `${tableName}${ext}`);
+		try {
+			await access(candidate);
+			return candidate;
+		} catch {}
+	}
+}
+/**
+* Synchronously find a schema file among directory entries.
+* Returns the full path of the first match, or undefined.
+*/
+function findSchemaFileInEntries(dataDirPath, tableName, entries) {
+	for (const ext of SCHEMA_EXTENSIONS) {
+		const candidateName = `${tableName}${ext}`;
+		if (entries.some((e) => e.isFile() && e.name === candidateName)) return join(dataDirPath, candidateName);
+	}
+}
+/**
+* Check if a filename matches any supported schema file pattern.
+*/
+function isSchemaFile(fileName) {
+	return SCHEMA_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+/**
+* Extract table name from a schema filename.
+* e.g., "users.schema.ts" -> "users", "users.schema.mts" -> "users"
+*/
+function extractTableNameFromSchemaFile(fileName) {
+	for (const ext of SCHEMA_EXTENSIONS) if (fileName.endsWith(ext)) return fileName.slice(0, -ext.length);
+	return null;
+}
+/**
+* Rewrite a TypeScript path to its JavaScript counterpart for ESM imports.
+* ".schema.ts" -> ".schema.js", ".schema.mts" -> ".schema.mjs", ".schema.cts" -> ".schema.cjs"
+*/
+function rewriteExtensionForImport(filePath) {
+	for (const [tsExt, jsExt] of Object.entries(SCHEMA_TO_JS_IMPORT_MAP)) if (filePath.endsWith(tsExt)) return filePath.slice(0, -tsExt.length) + jsExt;
+	return filePath;
+}
+
 //#endregion
 //#region src/schema-loader.ts
 var SchemaLoader = class {
@@ -166,27 +231,17 @@ var SchemaLoader = class {
 	* Check if a schema file exists for a table
 	*/
 	static async hasSchema(jsonlPath) {
-		const schemaPath = join(dirname(jsonlPath), `${basename(jsonlPath, ".jsonl")}.schema.ts`);
-		try {
-			await access(schemaPath);
-			return true;
-		} catch {
-			return false;
-		}
+		return await findSchemaFile(dirname(jsonlPath), basename(jsonlPath, ".jsonl")) !== void 0;
 	}
 	/**
 	* Load a validation schema file for a table
-	* Requires ${tableName}.schema.ts to exist alongside the JSONL file
+	* Requires ${tableName}.schema.{ts,mts,cts} to exist alongside the JSONL file
 	*/
 	static async loadSchema(jsonlPath) {
 		const dir = dirname(jsonlPath);
 		const tableName = basename(jsonlPath, ".jsonl");
-		const schemaPath = join(dir, `${tableName}.schema.ts`);
-		try {
-			await access(schemaPath);
-		} catch (error) {
-			throw new Error(`Schema file not found for table '${tableName}'. Expected: ${schemaPath}`, { cause: error instanceof Error ? error : void 0 });
-		}
+		const schemaPath = await findSchemaFile(dir, tableName);
+		if (!schemaPath) throw new Error(`Schema file not found for table '${tableName}'. Expected one of: ${SCHEMA_EXTENSIONS.map((ext) => `${tableName}${ext}`).join(", ")}`);
 		try {
 			const module = await import(`${pathToFileURL(schemaPath).href}?t=${Date.now()}`);
 			const schema = module.default || module.schema;
@@ -360,8 +415,11 @@ var LinesDB = class LinesDB {
 			let foreignKeys;
 			try {
 				const { pathToFileURL: pathToFileURL$1 } = await import("node:url");
-				const schemaModule = await import(`${pathToFileURL$1(tableConfig.jsonlPath.replace(".jsonl", ".schema.ts")).href}?t=${Date.now()}`);
-				foreignKeys = (schemaModule.schema || schemaModule.default)?.foreignKeys || schemaModule.foreignKeys;
+				const schemaPath = await findSchemaFile(dirname(tableConfig.jsonlPath), basename(tableConfig.jsonlPath, ".jsonl"));
+				if (schemaPath) {
+					const schemaModule = await import(`${pathToFileURL$1(schemaPath).href}?t=${Date.now()}`);
+					foreignKeys = (schemaModule.schema || schemaModule.default)?.foreignKeys || schemaModule.foreignKeys;
+				}
 			} catch {}
 			if (foreignKeys && foreignKeys.length > 0) for (const fk of foreignKeys) {
 				const referencedTable = fk.references.table;
@@ -401,7 +459,9 @@ var LinesDB = class LinesDB {
 		} catch (_error) {}
 		if (!config.validationSchema) try {
 			const { pathToFileURL: pathToFileURL$1 } = await import("node:url");
-			const schemaModule = await import(`${pathToFileURL$1(config.jsonlPath.replace(".jsonl", ".schema.ts")).href}?t=${Date.now()}`);
+			const schemaPath = await findSchemaFile(dirname(config.jsonlPath), basename(config.jsonlPath, ".jsonl"));
+			if (!schemaPath) throw new Error("Schema file not found");
+			const schemaModule = await import(`${pathToFileURL$1(schemaPath).href}?t=${Date.now()}`);
 			const schemaExport = schemaModule.schema || schemaModule.default;
 			if (schemaExport?.primaryKey) schemaMetadata.primaryKey = schemaExport.primaryKey;
 			else if (schemaModule.primaryKey) schemaMetadata.primaryKey = schemaModule.primaryKey;
@@ -1089,7 +1149,7 @@ var TypeGenerator = class {
 		this.projectRoot = envProjectRoot !== void 0 ? envProjectRoot : options.projectRoot || process.cwd();
 		this.dataDir = options.dataDir;
 		this.dataDirPath = isAbsolute(this.dataDir) ? this.dataDir : join(this.projectRoot, this.dataDir);
-		this.outputFile = join(this.dataDirPath, "db.ts");
+		this.outputFile = options.output ? isAbsolute(options.output) ? options.output : join(this.projectRoot, options.output) : join(this.dataDirPath, "db.ts");
 	}
 	/**
 	* Generate types file from JSONL files and their optional schema files.
@@ -1112,12 +1172,10 @@ var TypeGenerator = class {
 			const tables = [];
 			for (const entry of entries) if (entry.isFile() && entry.name.endsWith(".jsonl")) {
 				const tableName = basename(entry.name, ".jsonl");
-				const schemaFileName = `${tableName}.schema.ts`;
-				const schemaFilePath = join(this.dataDirPath, schemaFileName);
-				const hasSchema = entries.some((e) => e.isFile() && e.name === schemaFileName);
+				const schemaFilePath = findSchemaFileInEntries(this.dataDirPath, tableName, entries);
 				tables.push({
 					tableName,
-					schemaFile: hasSchema ? schemaFilePath : void 0
+					schemaFile: schemaFilePath
 				});
 			}
 			return tables;
@@ -1138,7 +1196,7 @@ var TypeGenerator = class {
 			if (table.schemaFile) {
 				const schemaIdentifier = this.createSchemaIdentifier(table.tableName, usedAliases);
 				usedAliases.add(schemaIdentifier);
-				let relativePath = relative(join(this.outputFile, ".."), table.schemaFile).replace(/\\/g, "/").replace(".ts", ".js");
+				let relativePath = rewriteExtensionForImport(relative(join(this.outputFile, ".."), table.schemaFile).replace(/\\/g, "/"));
 				if (!relativePath.startsWith(".")) relativePath = "./" + relativePath;
 				imports.push(`import { schema as ${schemaIdentifier} } from '${relativePath}';`);
 				tableEntries.push(`  ${tableKey}: InferOutput<typeof ${schemaIdentifier}>;`);
@@ -1214,5 +1272,5 @@ async function ensureTableRowsValid(options) {
 }
 
 //#endregion
-export { DirectoryScanner, JsonlReader, JsonlWriter, LinesDB, RUNTIME, SchemaLoader, TypeGenerator, defineSchema, detectRuntime, ensureTableRowsValid, hasBackward };
+export { DirectoryScanner, JsonlReader, JsonlWriter, LinesDB, RUNTIME, SCHEMA_EXTENSIONS, SchemaLoader, TypeGenerator, defineSchema, detectRuntime, ensureTableRowsValid, extractTableNameFromSchemaFile, findSchemaFile, hasBackward, isSchemaFile, rewriteExtensionForImport };
 //# sourceMappingURL=index.js.map