@aigne/afs-sqlite 1.11.0-beta.4 → 1.11.0-beta.6

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs

@@ -0,0 +1,11 @@
+
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+exports.__decorate = __decorate;

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+export { __decorate };

package/dist/actions/built-in.cjs

@@ -17,19 +17,6 @@ async function execRun(db, query) {
 * Registers built-in actions to the registry
 */
 function registerBuiltInActions(registry) {
-	registry.register({
-		name: "refresh",
-		description: "Refresh the schema cache for this module",
-		tableLevel: true,
-		rowLevel: false,
-		handler: async (ctx) => {
-			await ctx.module.refreshSchema();
-			return {
-				success: true,
-				message: "Schema refreshed successfully"
-			};
-		}
-	});
 	registry.register({
 		name: "export",
 		description: "Export table data in specified format (json, csv)",
@@ -68,12 +55,20 @@ function registerBuiltInActions(registry) {
 		description: "Create a copy of this row",
 		tableLevel: false,
 		rowLevel: true,
+		inputSchemaGenerator: (schemaCtx) => {
+			if (!schemaCtx.tableSchema) return {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			};
+			return generateDuplicateSchema(schemaCtx.tableSchema);
+		},
 		handler: async (ctx) => {
 			if (!ctx.row) return {
 				success: false,
 				message: "Row data not available"
 			};
-			const schema = ctx.schemas.get(ctx.table);
+			const schema = await ctx.schemaService.getSchema(ctx.table);
 			if (!schema) return {
 				success: false,
 				message: `Table '${ctx.table}' not found`
@@ -97,12 +92,20 @@ function registerBuiltInActions(registry) {
 		description: "Validate row data against schema constraints",
 		tableLevel: false,
 		rowLevel: true,
+		inputSchemaGenerator: (schemaCtx) => {
+			if (!schemaCtx.tableSchema) return {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			};
+			return generateValidateSchema(schemaCtx.tableSchema);
+		},
 		handler: async (ctx) => {
 			if (!ctx.row) return {
 				success: false,
 				message: "Row data not available"
 			};
-			const schema = ctx.schemas.get(ctx.table);
+			const schema = await ctx.schemaService.getSchema(ctx.table);
 			if (!schema) return {
 				success: false,
 				message: `Table '${ctx.table}' not found`
@@ -125,6 +128,306 @@ function registerBuiltInActions(registry) {
 			};
 		}
 	});
+	registry.register({
+		name: "create-table",
+		description: "Create a new table in the database",
+		rootLevel: true,
+		tableLevel: false,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			description: "Create a new SQLite table with specified columns",
+			properties: {
+				name: {
+					type: "string",
+					description: "Table name (alphanumeric and underscores, must start with letter)",
+					pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
+					minLength: 1,
+					maxLength: 128
+				},
+				columns: {
+					type: "array",
+					description: "Column definitions (at least one required)",
+					minItems: 1,
+					items: {
+						type: "object",
+						description: "Column definition",
+						properties: {
+							name: {
+								type: "string",
+								description: "Column name (alphanumeric and underscores)",
+								pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$",
+								minLength: 1,
+								maxLength: 128
+							},
+							type: {
+								type: "string",
+								description: "SQLite column type",
+								enum: [
+									"INTEGER",
+									"TEXT",
+									"REAL",
+									"BLOB",
+									"NUMERIC",
+									"INT",
+									"TINYINT",
+									"SMALLINT",
+									"MEDIUMINT",
+									"BIGINT",
+									"UNSIGNED BIG INT",
+									"INT2",
+									"INT8",
+									"CHARACTER",
+									"VARCHAR",
+									"VARYING CHARACTER",
+									"NCHAR",
+									"NATIVE CHARACTER",
+									"NVARCHAR",
+									"CLOB",
+									"DOUBLE",
+									"DOUBLE PRECISION",
+									"FLOAT",
+									"DECIMAL",
+									"BOOLEAN",
+									"DATE",
+									"DATETIME",
+									"TIMESTAMP"
+								],
+								"x-affinity-mapping": {
+									INTEGER: [
+										"INTEGER",
+										"INT",
+										"TINYINT",
+										"SMALLINT",
+										"MEDIUMINT",
+										"BIGINT",
+										"UNSIGNED BIG INT",
+										"INT2",
+										"INT8"
+									],
+									TEXT: [
+										"TEXT",
+										"CHARACTER",
+										"VARCHAR",
+										"VARYING CHARACTER",
+										"NCHAR",
+										"NATIVE CHARACTER",
+										"NVARCHAR",
+										"CLOB"
+									],
+									REAL: [
+										"REAL",
+										"DOUBLE",
+										"DOUBLE PRECISION",
+										"FLOAT"
+									],
+									NUMERIC: [
+										"NUMERIC",
+										"DECIMAL",
+										"BOOLEAN",
+										"DATE",
+										"DATETIME",
+										"TIMESTAMP"
+									],
+									BLOB: ["BLOB"]
+								}
+							},
+							nullable: {
+								type: "boolean",
+								description: "Whether the column allows NULL values (default: true)",
+								default: true
+							},
+							primaryKey: {
+								type: "boolean",
+								description: "Whether this column is the primary key (default: false). INTEGER PRIMARY KEY will auto-increment.",
+								default: false
+							},
+							unique: {
+								type: "boolean",
+								description: "Whether this column must have unique values (default: false)",
+								default: false
+							},
+							defaultValue: {
+								oneOf: [
+									{ type: "string" },
+									{ type: "number" },
+									{ type: "boolean" },
+									{ type: "null" }
+								],
+								description: "Default value for the column. Use string 'CURRENT_TIMESTAMP' for auto timestamp."
+							},
+							references: {
+								type: "object",
+								description: "Foreign key reference",
+								properties: {
+									table: {
+										type: "string",
+										description: "Referenced table name"
+									},
+									column: {
+										type: "string",
+										description: "Referenced column name"
+									},
+									onDelete: {
+										type: "string",
+										enum: [
+											"CASCADE",
+											"SET NULL",
+											"SET DEFAULT",
+											"RESTRICT",
+											"NO ACTION"
+										],
+										description: "Action on delete (default: NO ACTION)"
+									},
+									onUpdate: {
+										type: "string",
+										enum: [
+											"CASCADE",
+											"SET NULL",
+											"SET DEFAULT",
+											"RESTRICT",
+											"NO ACTION"
+										],
+										description: "Action on update (default: NO ACTION)"
+									}
+								},
+								required: ["table", "column"]
+							}
+						},
+						required: ["name", "type"],
+						additionalProperties: false
+					}
+				},
+				ifNotExists: {
+					type: "boolean",
+					description: "If true, do not throw error if table already exists (default: false)",
+					default: false
+				}
+			},
+			required: ["name", "columns"],
+			additionalProperties: false
+		},
+		handler: async (ctx, params) => {
+			const tableName = params.name;
+			const columns = params.columns;
+			const ifNotExists = params.ifNotExists;
+			if (!tableName) throw new Error("Table name is required");
+			if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(tableName)) throw new Error("Table name must start with a letter and contain only alphanumeric characters and underscores");
+			if (!columns || columns.length === 0) throw new Error("At least one column is required");
+			for (const col of columns) if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(col.name)) throw new Error(`Invalid column name: ${col.name}. Must start with a letter or underscore and contain only alphanumeric characters and underscores`);
+			const validTypes = [
+				"INTEGER",
+				"TEXT",
+				"REAL",
+				"BLOB",
+				"NUMERIC",
+				"INT",
+				"TINYINT",
+				"SMALLINT",
+				"MEDIUMINT",
+				"BIGINT",
+				"UNSIGNED BIG INT",
+				"INT2",
+				"INT8",
+				"CHARACTER",
+				"VARCHAR",
+				"VARYING CHARACTER",
+				"NCHAR",
+				"NATIVE CHARACTER",
+				"NVARCHAR",
+				"CLOB",
+				"DOUBLE",
+				"DOUBLE PRECISION",
+				"FLOAT",
+				"DECIMAL",
+				"BOOLEAN",
+				"DATE",
+				"DATETIME",
+				"TIMESTAMP"
+			];
+			for (const col of columns) {
+				const upperType = col.type.toUpperCase();
+				if (!validTypes.includes(upperType)) throw new Error(`Invalid column type: ${col.type}. Valid types are: ${validTypes.join(", ")}`);
+			}
+			if (!ifNotExists) {
+				if (await ctx.schemaService.hasTable(tableName)) throw new Error(`Table '${tableName}' already exists`);
+			}
+			const columnDefs = [];
+			const foreignKeys = [];
+			for (const col of columns) {
+				const parts = [`"${col.name}"`, col.type.toUpperCase()];
+				if (col.primaryKey) {
+					parts.push("PRIMARY KEY");
+					if (col.type.toUpperCase() === "INTEGER" || col.type.toUpperCase() === "INT") parts.push("AUTOINCREMENT");
+				}
+				if (col.nullable === false && !col.primaryKey) parts.push("NOT NULL");
+				if (col.unique && !col.primaryKey) parts.push("UNIQUE");
+				if (col.defaultValue !== void 0) if (col.defaultValue === "CURRENT_TIMESTAMP" || col.defaultValue === "CURRENT_DATE" || col.defaultValue === "CURRENT_TIME") parts.push(`DEFAULT ${col.defaultValue}`);
+				else parts.push(`DEFAULT ${formatValueForSQL(col.defaultValue)}`);
+				columnDefs.push(parts.join(" "));
+				if (col.references) {
+					let fkDef = `FOREIGN KEY ("${col.name}") REFERENCES "${col.references.table}"("${col.references.column}")`;
+					if (col.references.onDelete) fkDef += ` ON DELETE ${col.references.onDelete}`;
+					if (col.references.onUpdate) fkDef += ` ON UPDATE ${col.references.onUpdate}`;
+					foreignKeys.push(fkDef);
+				}
+			}
+			const allDefs = [...columnDefs, ...foreignKeys];
+			const createSQL = `CREATE TABLE ${ifNotExists ? "IF NOT EXISTS " : ""}"${tableName}" (${allDefs.join(", ")})`;
+			await execRun(ctx.db, createSQL);
+			return {
+				success: true,
+				data: {
+					tableName,
+					columnCount: columns.length,
+					sql: createSQL
+				},
+				message: `Table '${tableName}' created successfully`
+			};
+		}
+	});
+	registry.register({
+		name: "insert",
+		description: "Insert a new row into the table",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchemaGenerator: (schemaCtx) => {
+			if (!schemaCtx.tableSchema) return {
+				type: "object",
+				properties: { data: {
+					type: "object",
+					description: "Row data to insert (column names as keys)",
+					additionalProperties: true
+				} },
+				required: ["data"]
+			};
+			return generateInsertSchema(schemaCtx.tableSchema);
+		},
+		handler: async (ctx, params) => {
+			const data = params.data;
+			if (!data || Object.keys(data).length === 0) throw new Error("Insert data is required");
+			if (!await ctx.schemaService.getSchema(ctx.table)) throw new Error(`Table '${ctx.table}' not found`);
+			const columns = Object.keys(data);
+			const values = columns.map((col) => formatValueForSQL(data[col]));
+			const insertSQL = `INSERT INTO "${ctx.table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${values.join(", ")})`;
+			try {
+				await execRun(ctx.db, insertSQL);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(`Insert failed: ${message}`);
+			}
+			const newId = (await execAll(ctx.db, "SELECT last_insert_rowid() as id"))[0]?.id;
+			return {
+				success: true,
+				data: {
+					id: newId,
+					...data
+				},
+				message: `Row inserted successfully with id ${newId}`
+			};
+		}
+	});
 }
 /**
 * Formats a value for SQL insertion
@@ -137,6 +440,96 @@ function formatValueForSQL(value) {
 	if (typeof value === "object") return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
 	return `'${String(value).replace(/'/g, "''")}'`;
 }
+/**
+* Maps SQLite column type to JSON Schema type
+*/
+function sqliteTypeToJsonSchema(sqliteType) {
+	const upperType = sqliteType.toUpperCase();
+	if (upperType.includes("INT")) return { type: "integer" };
+	if (upperType.includes("REAL") || upperType.includes("FLOAT") || upperType.includes("DOUBLE")) return { type: "number" };
+	if (upperType.includes("BOOL")) return {
+		type: "boolean",
+		description: "Stored as INTEGER (0/1)"
+	};
+	if (upperType.includes("DATE") || upperType.includes("TIME")) return {
+		type: "string",
+		format: "date-time"
+	};
+	if (upperType.includes("BLOB")) return {
+		type: "string",
+		format: "binary",
+		description: "Base64 encoded binary data"
+	};
+	return { type: "string" };
+}
+/**
+* Generates JSON Schema for insert action based on table schema
+*/
+function generateInsertSchema(tableSchema) {
+	const properties = {};
+	const required = [];
+	for (const col of tableSchema.columns) {
+		if (col.pk > 0 && col.type.toUpperCase().includes("INTEGER")) continue;
+		const propSchema = { ...sqliteTypeToJsonSchema(col.type) };
+		if (col.dfltValue !== null) {
+			propSchema.default = col.dfltValue;
+			propSchema.description = `${propSchema.description ?? ""}${propSchema.description ? ". " : ""}Default: ${col.dfltValue}`.trim();
+		}
+		if (col.notnull && col.dfltValue === null && col.pk === 0) required.push(col.name);
+		properties[col.name] = propSchema;
+	}
+	return {
+		type: "object",
+		description: `Insert a new row into "${tableSchema.name}" table`,
+		properties: { data: {
+			type: "object",
+			description: "Row data to insert",
+			properties,
+			required: required.length > 0 ? required : void 0,
+			additionalProperties: false
+		} },
+		required: ["data"]
+	};
+}
+/**
+* Generates JSON Schema for validate action based on table schema
+*/
+function generateValidateSchema(tableSchema) {
+	const columnInfo = tableSchema.columns.map((col) => ({
+		name: col.name,
+		type: col.type,
+		nullable: !col.notnull,
+		primaryKey: col.pk > 0
+	}));
+	const foreignKeyInfo = tableSchema.foreignKeys.map((fk) => ({
+		column: fk.from,
+		references: `${fk.table}.${fk.to}`
+	}));
+	return {
+		type: "object",
+		description: `Validate row data against "${tableSchema.name}" table constraints`,
+		properties: {},
+		additionalProperties: false,
+		"x-table-schema": {
+			columns: columnInfo,
+			foreignKeys: foreignKeyInfo
+		}
+	};
+}
+/**
+* Generates JSON Schema for duplicate action based on table schema
+*/
+function generateDuplicateSchema(tableSchema) {
+	const pkColumn = tableSchema.primaryKey[0] ?? "rowid";
+	const copiedColumns = tableSchema.columns.filter((col) => col.name !== pkColumn).map((col) => col.name);
+	return {
+		type: "object",
+		description: `Create a copy of the row (excluding primary key "${pkColumn}")`,
+		properties: {},
+		additionalProperties: false,
+		"x-copied-columns": copiedColumns
+	};
+}
 
 //#endregion
 exports.registerBuiltInActions = registerBuiltInActions;

package/dist/actions/built-in.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"built-in.d.cts","names":[],"sources":["../../src/actions/built-in.ts"],"mappings":";;;;AAsBA;;iBAAgB,sBAAA,CAAA,QAAA,EAAiC,eAAA"}
+{"version":3,"file":"built-in.d.cts","names":[],"sources":["../../src/actions/built-in.ts"],"mappings":";;;;;AAuBA;iBAAgB,sBAAA,CAAuB,QAAA,EAAU,eAAA"}

package/dist/actions/built-in.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"built-in.d.mts","names":[],"sources":["../../src/actions/built-in.ts"],"mappings":";;;;AAsBA;;iBAAgB,sBAAA,CAAA,QAAA,EAAiC,eAAA"}
+{"version":3,"file":"built-in.d.mts","names":[],"sources":["../../src/actions/built-in.ts"],"mappings":";;;;;AAuBA;iBAAgB,sBAAA,CAAuB,QAAA,EAAU,eAAA"}