driftsql 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/postgres-CFQEP3ft.js

@@ -0,0 +1,4 @@
+import { n as init_postgres, t as PostgresGenerator } from "./postgres-CjYq8GvL.js";
+
+init_postgres();
+export { PostgresGenerator };

package/dist/postgres-CjYq8GvL.js

@@ -0,0 +1,95 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
+//#region src/schema/generators/postgres.ts
+var postgres_exports = /* @__PURE__ */ __export({ PostgresGenerator: () => PostgresGenerator });
+var PostgresGenerator;
+var init_postgres = __esm({ "src/schema/generators/postgres.ts": (() => {
+	PostgresGenerator = class {
+		generateCreateTable(table) {
+			const lines = [];
+			lines.push(`CREATE TABLE "${table.name}" (`);
+			const columnDefs = [];
+			for (const column of table.columns) columnDefs.push("  " + this.generateColumnDefinition(column));
+			if (table.primaryKey && table.primaryKey.length > 0) {
+				const pkColumns = table.primaryKey.map((col) => `"${col}"`).join(", ");
+				columnDefs.push(`  PRIMARY KEY (${pkColumns})`);
+			}
+			if (table.checks && table.checks.length > 0) for (const check of table.checks) columnDefs.push(`  CONSTRAINT "${check.name}" CHECK (${check.expression})`);
+			lines.push(columnDefs.join(",\n"));
+			lines.push(");");
+			const sql = [lines.join("\n")];
+			if (table.indexes && table.indexes.length > 0) for (const index of table.indexes) sql.push(this.generateIndex(table.name, index));
+			return sql.join("\n\n");
+		}
+		generateDropTable(tableName) {
+			return `DROP TABLE IF EXISTS "${tableName}" CASCADE;`;
+		}
+		generateColumnDefinition(column) {
+			const parts = [`"${column.name}"`];
+			parts.push(this.getColumnType(column));
+			if (column.primaryKey && !column.type.includes("serial")) parts.push("PRIMARY KEY");
+			if (column.notNull && !column.primaryKey && !column.type.includes("serial")) parts.push("NOT NULL");
+			if (column.unique) parts.push("UNIQUE");
+			if (column.default !== void 0) parts.push(`DEFAULT ${this.formatDefault(column.default)}`);
+			if (column.references) {
+				const ref = column.references;
+				parts.push(`REFERENCES "${ref.table}"("${ref.column}")`);
+				if (ref.onDelete) parts.push(`ON DELETE ${ref.onDelete}`);
+				if (ref.onUpdate) parts.push(`ON UPDATE ${ref.onUpdate}`);
+			}
+			if (column.check) parts.push(`CHECK (${column.check})`);
+			return parts.join(" ");
+		}
+		getColumnType(column) {
+			let type = column.type.toUpperCase();
+			if (column.length) type += `(${column.length})`;
+			else if (column.precision) if (column.scale !== void 0) type += `(${column.precision}, ${column.scale})`;
+			else type += `(${column.precision})`;
+			return type;
+		}
+		formatDefault(value) {
+			if (typeof value === "string") {
+				if (value.toUpperCase() === "NOW()" || value.toUpperCase() === "CURRENT_TIMESTAMP") return value.toUpperCase();
+				return `'${value}'`;
+			}
+			if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+			return String(value);
+		}
+		generateIndex(tableName, index) {
+			const unique = index.unique ? "UNIQUE " : "";
+			const type = index.type ? ` USING ${index.type.toUpperCase()}` : "";
+			const columns = index.columns.map((col) => `"${col}"`).join(", ");
+			return `CREATE ${unique}INDEX "${index.name}" ON "${tableName}"${type} (${columns});`;
+		}
+	};
+}) });
+
+//#endregion
+export { __export as a, __esm as i, init_postgres as n, __toCommonJS as o, postgres_exports as r, PostgresGenerator as t };

package/dist/type-generator-Ba8bgnMm.js

@@ -1,7 +1,88 @@
-import e from"node:fs/promises";var t=class{generateTypes(e){let t=`// This file was automatically generated - DO NOT EDIT
+import fs from "node:fs/promises";
 
-`;for(let n of e)t+=this.generateTableInterface(n),t+=`
+//#region src/schema/type-generator.ts
+var TypeGenerator = class {
+	generateTypes(tables) {
+		let output = "// This file was automatically generated - DO NOT EDIT\n\n";
+		for (const table of tables) {
+			output += this.generateTableInterface(table);
+			output += "\n\n";
+		}
+		output += this.generateDatabaseInterface(tables);
+		return output;
+	}
+	generateTableInterface(table) {
+		let lines = [`export interface ${this.pascalCase(table.name)} {`];
+		for (const column of table.columns) {
+			const tsType = this.columnToTypeScript(column);
+			const optional = !column.notNull && !column.primaryKey ? "?" : "";
+			lines.push(`  ${column.name}${optional}: ${tsType}`);
+		}
+		lines.push("}");
+		return lines.join("\n");
+	}
+	generateDatabaseInterface(tables) {
+		let lines = ["export interface Database {"];
+		for (const table of tables) {
+			const interfaceName = this.pascalCase(table.name);
+			lines.push(`  ${table.name}: ${interfaceName}`);
+		}
+		lines.push("}");
+		return lines.join("\n");
+	}
+	columnToTypeScript(column) {
+		const isNullable = !column.notNull && !column.primaryKey;
+		let baseType;
+		switch (column.type.toLowerCase()) {
+			case "serial":
+			case "bigserial":
+			case "integer":
+			case "int":
+			case "bigint":
+			case "smallint":
+			case "numeric":
+			case "decimal":
+			case "real":
+			case "double precision":
+				baseType = "number";
+				break;
+			case "text":
+			case "varchar":
+			case "char":
+			case "uuid":
+				baseType = "string";
+				break;
+			case "boolean":
+				baseType = "boolean";
+				break;
+			case "timestamp":
+			case "timestamptz":
+			case "date":
+			case "time":
+				baseType = "Date | string";
+				break;
+			case "json":
+			case "jsonb":
+				baseType = "any";
+				break;
+			case "bytea":
+				baseType = "Buffer";
+				break;
+			default: baseType = "any";
+		}
+		return isNullable ? `${baseType} | null` : baseType;
+	}
+	pascalCase(str) {
+		return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+	}
+	async writeToFile(tables, filePath) {
+		const content = this.generateTypes(tables);
+		await fs.writeFile(filePath, content, "utf8");
+	}
+};
+async function generateTypesFromSchema(tables, outputPath) {
+	await new TypeGenerator().writeToFile(tables, outputPath);
+}
 
-`;return t+=this.generateDatabaseInterface(e),t}generateTableInterface(e){let t=[`export interface ${this.pascalCase(e.name)} {`];for(let n of e.columns){let e=this.columnToTypeScript(n),r=!n.notNull&&!n.primaryKey?`?`:``;t.push(`  ${n.name}${r}: ${e}`)}return t.push(`}`),t.join(`
-`)}generateDatabaseInterface(e){let t=[`export interface Database {`];for(let n of e){let e=this.pascalCase(n.name);t.push(`  ${n.name}: ${e}`)}return t.push(`}`),t.join(`
-`)}columnToTypeScript(e){let t=!e.notNull&&!e.primaryKey,n;switch(e.type.toLowerCase()){case`serial`:case`bigserial`:case`integer`:case`int`:case`bigint`:case`smallint`:case`numeric`:case`decimal`:case`real`:case`double precision`:n=`number`;break;case`text`:case`varchar`:case`char`:case`uuid`:n=`string`;break;case`boolean`:n=`boolean`;break;case`timestamp`:case`timestamptz`:case`date`:case`time`:n=`Date | string`;break;case`json`:case`jsonb`:n=`any`;break;case`bytea`:n=`Buffer`;break;default:n=`any`}return t?`${n} | null`:n}pascalCase(e){return e.split(`_`).map(e=>e.charAt(0).toUpperCase()+e.slice(1).toLowerCase()).join(``)}async writeToFile(t,n){let r=this.generateTypes(t);await e.writeFile(n,r,`utf8`)}};async function n(e,n){await new t().writeToFile(e,n)}export{n,t};
+//#endregion
+export { generateTypesFromSchema as n, TypeGenerator as t };

package/dist/type-generator-DbcqBk-4.js

@@ -1 +1,3 @@
-import{n as e,t}from"./type-generator-Ba8bgnMm.js";export{t as TypeGenerator,e as generateTypesFromSchema};
+import { n as generateTypesFromSchema, t as TypeGenerator } from "./type-generator-Ba8bgnMm.js";
+
+export { TypeGenerator, generateTypesFromSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftsql",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.4",
   "description": "A modern, type-safe SQL client with built-in schema builder and migration system for TypeScript.",
   "type": "module",
   "license": "MIT",

package/dist/postgres-9C7eE0wB.js

@@ -1,5 +0,0 @@
-var e=Object.defineProperty,t=Object.getOwnPropertyDescriptor,n=Object.getOwnPropertyNames,r=Object.prototype.hasOwnProperty,i=(e,t)=>()=>(e&&(t=e(e=0)),t),a=t=>{let n={};for(var r in t)e(n,r,{get:t[r],enumerable:!0});return n},o=(i,a,o,s)=>{if(a&&typeof a==`object`||typeof a==`function`)for(var c=n(a),l=0,u=c.length,d;l<u;l++)d=c[l],!r.call(i,d)&&d!==o&&e(i,d,{get:(e=>a[e]).bind(null,d),enumerable:!(s=t(a,d))||s.enumerable});return i},s=t=>o(e({},`__esModule`,{value:!0}),t),c=a({PostgresGenerator:()=>l}),l,u=i((()=>{l=class{generateCreateTable(e){let t=[];t.push(`CREATE TABLE "${e.name}" (`);let n=[];for(let t of e.columns)n.push(`  `+this.generateColumnDefinition(t));if(e.primaryKey&&e.primaryKey.length>0){let t=e.primaryKey.map(e=>`"${e}"`).join(`, `);n.push(`  PRIMARY KEY (${t})`)}if(e.checks&&e.checks.length>0)for(let t of e.checks)n.push(`  CONSTRAINT "${t.name}" CHECK (${t.expression})`);t.push(n.join(`,
-`)),t.push(`);`);let r=[t.join(`
-`)];if(e.indexes&&e.indexes.length>0)for(let t of e.indexes)r.push(this.generateIndex(e.name,t));return r.join(`
-
-`)}generateDropTable(e){return`DROP TABLE IF EXISTS "${e}" CASCADE;`}generateColumnDefinition(e){let t=[`"${e.name}"`];if(t.push(this.getColumnType(e)),e.primaryKey&&!e.type.includes(`serial`)&&t.push(`PRIMARY KEY`),e.notNull&&!e.primaryKey&&!e.type.includes(`serial`)&&t.push(`NOT NULL`),e.unique&&t.push(`UNIQUE`),e.default!==void 0&&t.push(`DEFAULT ${this.formatDefault(e.default)}`),e.references){let n=e.references;t.push(`REFERENCES "${n.table}"("${n.column}")`),n.onDelete&&t.push(`ON DELETE ${n.onDelete}`),n.onUpdate&&t.push(`ON UPDATE ${n.onUpdate}`)}return e.check&&t.push(`CHECK (${e.check})`),t.join(` `)}getColumnType(e){let t=e.type.toUpperCase();return e.length?t+=`(${e.length})`:e.precision&&(e.scale===void 0?t+=`(${e.precision})`:t+=`(${e.precision}, ${e.scale})`),t}formatDefault(e){return typeof e==`string`?e.toUpperCase()===`NOW()`||e.toUpperCase()===`CURRENT_TIMESTAMP`?e.toUpperCase():`'${e}'`:typeof e==`boolean`?e?`TRUE`:`FALSE`:String(e)}generateIndex(e,t){let n=t.unique?`UNIQUE `:``,r=t.type?` USING ${t.type.toUpperCase()}`:``,i=t.columns.map(e=>`"${e}"`).join(`, `);return`CREATE ${n}INDEX "${t.name}" ON "${e}"${r} (${i});`}}}));export{a,i,u as n,s as o,c as r,l as t};

package/dist/postgres-DWtAqXNK.js

@@ -1 +0,0 @@
-import{n as e,t}from"./postgres-9C7eE0wB.js";e();export{t as PostgresGenerator};