aiex-cli 0.1.1-beta.1 → 0.1.1-beta.3

package/dist/{generate-drizzle-schema-CaSMqQWx.mjs → generate-drizzle-schema-DbJcRtaQ.mjs}

@@ -11,7 +11,7 @@ import { z } from "zod";
 
 //#region package.json
 var name = "aiex-cli";
-var version = "0.1.1-beta.1";
+var version = "0.1.1-beta.3";
 var description = "JSON Schema → SQLite with AI-powered data extraction";
 var package_default = {
 	name,
@@ -405,9 +405,59 @@ function getColumnChecks(prop, colName) {
 			value: prop.maximum
 		});
 	}
+	if (prop.enum?.length) checks.push({
+		name: `${colName}_enum`,
+		column: colName,
+		kind: "enum_value",
+		value: prop.enum
+	});
 	return checks;
 }
-function parseObjectToTable(schema, _warnings) {
+function warnNonDrizzleBackedProperty(warnings, schemaPath, property) {
+	if (property.pattern) warnings.push(`${schemaPath}.pattern is kept for extraction guidance but is not emitted as a SQLite constraint because SQLite has no portable REGEXP support.`);
+}
+function describeColumnType(columnType) {
+	switch (columnType.class) {
+		case "text": return {
+			drizzleType: columnType.mode === "json" ? `text({ mode: 'json' })` : "text()",
+			sqliteType: "text"
+		};
+		case "integer": return {
+			drizzleType: columnType.mode ? `integer({ mode: '${columnType.mode}' })` : "integer()",
+			sqliteType: "integer"
+		};
+		case "real": return {
+			drizzleType: "real()",
+			sqliteType: "real"
+		};
+	}
+}
+function columnNotes(property, column) {
+	const notes = [];
+	if (property.type === "object" || property.type === "array") notes.push("stored_as_json");
+	if (property.format === "date-time") notes.push("date_time_as_timestamp");
+	if (property.drizzle?.mode) notes.push(`drizzle_mode:${property.drizzle.mode}`);
+	if (property.foreignKey) notes.push(`foreign_key:${property.foreignKey.table}.${property.foreignKey.column}`);
+	if (column.default !== void 0) notes.push("default");
+	return notes;
+}
+function mapColumnToReport(schemaPath, table, property, column, relation) {
+	const columnType = describeColumnType(column.columnType);
+	return {
+		schemaPath,
+		table,
+		column: column.name,
+		drizzleType: columnType.drizzleType,
+		sqliteType: columnType.sqliteType,
+		nullable: column.isNullable,
+		primary: column.isPrimary,
+		unique: column.isUnique,
+		relation,
+		constraints: property.enum?.length ? { enumValues: property.enum } : void 0,
+		notes: columnNotes(property, column)
+	};
+}
+function parseObjectToTable(schema, warnings, mapping) {
 	const tableName = schema.table.name;
 	const columns = [];
 	const checks = [];
@@ -426,6 +476,8 @@ function parseObjectToTable(schema, _warnings) {
 		const column = mapPropertyToColumn(propName, prop, requiredFields.has(propName));
 		columns.push(column);
 		checks.push(...getColumnChecks(prop, column.name));
+		warnNonDrizzleBackedProperty(warnings, `$.properties.${propName}`, prop);
+		mapping.push(mapColumnToReport(`$.properties.${propName}`, tableName, prop, column, "root"));
 	}
 	if (schema.table.timestamps) {
 		const tsCol = {
@@ -444,18 +496,36 @@ function parseObjectToTable(schema, _warnings) {
 			...tsCol,
 			name: "updated_at"
 		});
+		mapping.push(mapColumnToReport("$.table.timestamps.createdAt", tableName, {
+			type: "integer",
+			drizzle: { mode: "timestamp" }
+		}, tsCol, "root"));
+		mapping.push(mapColumnToReport("$.table.timestamps.updatedAt", tableName, {
+			type: "integer",
+			drizzle: { mode: "timestamp" }
+		}, {
+			...tsCol,
+			name: "updated_at"
+		}, "root"));
+	}
+	if (schema.table.softDelete) {
+		const deletedAt = {
+			name: "deleted_at",
+			columnType: {
+				class: "integer",
+				mode: "timestamp"
+			},
+			isPrimary: false,
+			isAutoIncrement: false,
+			isNullable: true,
+			isUnique: false
+		};
+		columns.push(deletedAt);
+		mapping.push(mapColumnToReport("$.table.softDelete.deletedAt", tableName, {
+			type: "integer",
+			drizzle: { mode: "timestamp" }
+		}, deletedAt, "root"));
 	}
-	if (schema.table.softDelete) columns.push({
-		name: "deleted_at",
-		columnType: {
-			class: "integer",
-			mode: "timestamp"
-		},
-		isPrimary: false,
-		isAutoIncrement: false,
-		isNullable: true,
-		isUnique: false
-	});
 	return checks.length > 0 ? {
 		name: tableName,
 		columns,
@@ -465,7 +535,7 @@ function parseObjectToTable(schema, _warnings) {
 		columns
 	};
 }
-function parseNestedObject(propName, property, parentTableName, warnings) {
+function parseNestedObject(propName, property, parentTableName, warnings, mapping) {
 	const nestedTableName = `${parentTableName}_${toSnakeCase(propName)}`;
 	const columns = [];
 	const checks = [];
@@ -478,6 +548,18 @@ function parseNestedObject(propName, property, parentTableName, warnings) {
 		isNullable: false,
 		isUnique: false
 	});
+	mapping.push({
+		schemaPath: `$.properties.${propName}.id`,
+		table: nestedTableName,
+		column: "id",
+		drizzleType: "integer().primaryKey({ autoIncrement: true })",
+		sqliteType: "integer",
+		nullable: false,
+		primary: true,
+		unique: false,
+		relation: relationType,
+		notes: ["generated_nested_primary_key"]
+	});
 	columns.push({
 		name: `${parentTableName}_id`,
 		columnType: { class: "integer" },
@@ -491,6 +573,18 @@ function parseNestedObject(propName, property, parentTableName, warnings) {
 			column: "id"
 		}
 	});
+	mapping.push({
+		schemaPath: `$.properties.${propName}.${parentTableName}Id`,
+		table: nestedTableName,
+		column: `${parentTableName}_id`,
+		drizzleType: "integer().references(...)",
+		sqliteType: "integer",
+		nullable: false,
+		primary: false,
+		unique: false,
+		relation: relationType,
+		notes: [`generated_parent_foreign_key:${parentTableName}.id`]
+	});
 	if (property.type === "object" && property.properties) for (const [childName, childProp] of Object.entries(property.properties)) {
 		if (childProp.nested?.enabled) {
 			warnings.push(`Nested property "${childName}" inside "${nestedTableName}" is skipped — only one level of nesting is supported. Remove nested.enabled or use drizzle.mode: 'json' instead.`);
@@ -499,6 +593,8 @@ function parseNestedObject(propName, property, parentTableName, warnings) {
 		const column = mapPropertyToColumn(childName, childProp, false);
 		columns.push(column);
 		checks.push(...getColumnChecks(childProp, column.name));
+		warnNonDrizzleBackedProperty(warnings, `$.properties.${propName}.properties.${childName}`, childProp);
+		mapping.push(mapColumnToReport(`$.properties.${propName}.properties.${childName}`, nestedTableName, childProp, column, relationType));
 	}
 	const relation = {
 		fromTable: nestedTableName,
@@ -531,15 +627,16 @@ function parseJsonSchema(schema) {
 	const relations = [];
 	const reverseRelations = [];
 	const warnings = [];
-	const mainTable = parseObjectToTable(schema, warnings);
+	const mapping = [];
+	const mainTable = parseObjectToTable(schema, warnings, mapping);
 	tables.push(mainTable);
 	for (const [propName, prop] of Object.entries(schema.properties)) if (prop.type === "object" && prop.nested?.enabled) {
-		const nested = parseNestedObject(propName, prop, mainTable.name, warnings);
+		const nested = parseNestedObject(propName, prop, mainTable.name, warnings, mapping);
 		tables.push(nested.table);
 		relations.push(nested.relation);
 		reverseRelations.push(nested.reverseRelation);
 	} else if (prop.type === "array" && prop.items?.nested?.enabled && prop.items?.type === "object" && prop.items.properties) {
-		const nested = parseNestedObject(propName, prop.items, mainTable.name, warnings);
+		const nested = parseNestedObject(propName, prop.items, mainTable.name, warnings, mapping);
 		tables.push(nested.table);
 		relations.push(nested.relation);
 		reverseRelations.push(nested.reverseRelation);
@@ -548,7 +645,8 @@ function parseJsonSchema(schema) {
 		tables,
 		relations,
 		reverseRelations,
-		warnings
+		warnings,
+		mapping
 	};
 }
 
@@ -561,10 +659,13 @@ const DrizzleModeSchema = z.enum([
 	"boolean",
 	"bigint"
 ]);
-const DrizzleExtensionSchema = z.object({
-	mode: DrizzleModeSchema.optional(),
-	customType: z.string().optional()
-}).optional();
+const FormatSchema = z.enum([
+	"date-time",
+	"email",
+	"uri",
+	"json"
+]);
+const DrizzleExtensionSchema = z.object({ mode: DrizzleModeSchema.optional() }).strict().optional();
 const NestedConfigSchema = z.object({
 	enabled: z.literal(true),
 	relation: z.enum(["has-one", "has-many"])
@@ -584,7 +685,7 @@ const JsonSchemaPropertySchema = z.lazy(() => z.object({
 		"array",
 		"null"
 	]),
-	format: z.string().optional(),
+	format: FormatSchema.optional(),
 	pattern: z.string().optional(),
 	enum: z.array(z.union([z.string(), z.number()])).optional(),
 	primary: z.boolean().optional(),
@@ -810,7 +911,8 @@ const en = {
 			description: "Sync JSON Schema to SQLite database",
 			args: {
 				generate: "Only generate Drizzle schema, skip migrate",
-				name: "Name for the migration"
+				name: "Name for the migration",
+				force: "Allow high-risk schema migrations"
 			},
 			noSchemas: "No schema files found in {{path}}",
 			runWebHint: "Run {{cmd}} to create and configure schemas in the Web UI",
@@ -825,7 +927,9 @@ const en = {
 			databaseMigrated: "Database migrated",
 			migrationsApplied: "Migrations applied",
 			migrationFail: "Migration failed",
-			runWithoutGenerate: "Done! Run without --generate to apply migrations"
+			runWithoutGenerate: "Done! Run without --generate to apply migrations",
+			riskSummary: "Migration risk: {{level}} ({{count}} item(s))",
+			highRiskBlocked: "High-risk schema migration blocked. Review .aiex/drizzle/schema-map.json and rerun with {{flag}} to continue."
 		},
 		extract: {
 			description: "Extract structured data from text, images, or PDFs",
@@ -991,7 +1095,8 @@ const en = {
 			noFiles: "No schema files found",
 			migrationFailed: "Migration failed",
 			migrationHelperInvalidOutput: "Migration helper did not return valid output",
-			migrationHelperFailed: "Migration helper failed"
+			migrationHelperFailed: "Migration helper failed",
+			highRiskMigrationBlocked: "High-risk schema migration blocked"
 		},
 		db: {
 			notFound: "Database not found at {{path}}. Run {{cmd}} first to create the database.",
@@ -1250,7 +1355,7 @@ async function initI18n(lng) {
 			fallbackLng: "en",
 			resources: {
 				"en": { translation: en },
-				"zh-CN": { translation: await import("./zh-CN-Cs4MViVi.mjs").then((m) => m.zhCN) }
+				"zh-CN": { translation: await import("./zh-CN-BAGJklRp.mjs").then((m) => m.zhCN) }
 			},
 			interpolation: { escapeValue: false },
 			returnNull: false
@@ -1592,6 +1697,9 @@ function renderColumnType(ct) {
 function renderDefaultValue(value) {
 	return JSON.stringify(value);
 }
+function renderSqlLiteral(value) {
+	return typeof value === "number" ? String(value) : `'${value.replace(/'/g, "''")}'`;
+}
 function generateColumnDefinition(column) {
 	if (column.isPrimary && column.isAutoIncrement) return `  ${column.name}: integer().primaryKey({ autoIncrement: true })`;
 	let def = `  ${column.name}: ${renderColumnType(column.columnType)}`;
@@ -1618,6 +1726,9 @@ function renderCheckToDrizzle(check, tableVar) {
 		case "max_value":
 			expr = `${colRef} <= ${check.value}`;
 			break;
+		case "enum_value":
+			expr = `${colRef} IN (${(Array.isArray(check.value) ? check.value : []).map(renderSqlLiteral).join(", ")})`;
+			break;
 	}
 	return `    ${check.name}: check('${check.name}', sql\`${expr}\`)`;
 }

package/dist/index.d.mts

@@ -264,7 +264,7 @@ interface ForeignKeyRef {
 interface JsonSchemaProperty {
   description?: string;
   type: 'string' | 'integer' | 'number' | 'boolean' | 'object' | 'array' | 'null';
-  format?: string;
+  format?: 'date-time' | 'email' | 'uri' | 'json';
   pattern?: string;
   enum?: (string | number)[];
   primary?: boolean;
@@ -279,7 +279,6 @@ interface JsonSchemaProperty {
   xPrompt?: string;
   drizzle?: {
     mode?: 'json' | 'timestamp' | 'timestamp_ms' | 'boolean' | 'bigint';
-    customType?: string;
   };
   nested?: {
     enabled: true;
@@ -305,8 +304,8 @@ type ColumnType = {
 interface CheckConstraint {
   name: string;
   column: string;
-  kind: 'min_length' | 'max_length' | 'min_value' | 'max_value';
-  value: number;
+  kind: 'min_length' | 'max_length' | 'min_value' | 'max_value' | 'enum_value';
+  value: number | (string | number)[];
 }
 interface ParsedColumn {
   name: string;
@@ -322,6 +321,21 @@ interface ParsedColumn {
     column: string;
   };
 }
+interface SchemaMappingEntry {
+  schemaPath: string;
+  table: string;
+  column: string;
+  drizzleType: string;
+  sqliteType: 'text' | 'integer' | 'real';
+  nullable: boolean;
+  primary: boolean;
+  unique: boolean;
+  relation?: 'root' | 'has-one' | 'has-many';
+  constraints?: {
+    enumValues?: (string | number)[];
+  };
+  notes: string[];
+}
 interface ParsedTable {
   name: string;
   columns: ParsedColumn[];
@@ -345,6 +359,7 @@ interface ParseResult {
   relations: ParsedRelation[];
   reverseRelations: ParsedReverseRelation[];
   warnings: string[];
+  mapping?: SchemaMappingEntry[];
 }
 interface MigrationConfig {
   schemaPath: string;

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { _ as doctorDiagnosticsSeverityRows, g as buildDoctorDiagnostics, i as generateDrizzleConfig, m as parseJsonSchema, n as collectDoctorDiagnostics, p as JsonSchemaDefinitionSchema, r as createMigrationConfig, t as generateDrizzleSchema, v as doctorDiagnosticsTableRows, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-CaSMqQWx.mjs";
+import { _ as doctorDiagnosticsSeverityRows, g as buildDoctorDiagnostics, i as generateDrizzleConfig, m as parseJsonSchema, n as collectDoctorDiagnostics, p as JsonSchemaDefinitionSchema, r as createMigrationConfig, t as generateDrizzleSchema, v as doctorDiagnosticsTableRows, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-DbJcRtaQ.mjs";
 
 export { JsonSchemaDefinitionSchema, buildDoctorDiagnostics, collectDoctorDiagnostics, createMigrationConfig, doctorDiagnosticsSeverityRows, doctorDiagnosticsTableRows, formatDoctorDiagnosticsJson, generateDrizzleConfig, generateDrizzleSchema, parseJsonSchema };

package/dist/table-schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://raw.githubusercontent.com/OSpoon/aiex-cli/main/app/cli/schemas/table-schema.json",
   "title": "aiex Table Schema",
-  "description": "Defines a database table and its columns for aiex-cli schema-to-SQLite migration.",
+  "description": "Defines an AIEX Drizzle-backed schema dialect file for schema-to-SQLite migration.",
   "type": "object",
   "required": ["title", "type", "table", "properties"],
   "additionalProperties": false,
@@ -40,6 +40,12 @@
       "items": { "type": "string" },
       "description": "List of property names that are NOT NULL.",
       "default": []
+    },
+    "examples": {
+      "type": "array",
+      "description": "Few-shot examples used by AI extraction prompts.",
+      "items": { "$ref": "#/$defs/examplePair" },
+      "default": []
     }
   },
 
@@ -113,12 +119,17 @@
         },
         "pattern": {
           "type": "string",
-          "description": "Regular expression constraint for string values."
+          "description": "Regular expression guidance for extraction and validation. Not emitted as a SQLite constraint because SQLite has no portable built-in REGEXP support."
         },
         "enum": {
           "type": "array",
-          "items": { "type": "string" },
-          "description": "Enumeration of allowed values for this field."
+          "items": {
+            "oneOf": [
+              { "type": "string" },
+              { "type": "number" }
+            ]
+          },
+          "description": "Enumeration of allowed values for this field. Emitted as a SQLite CHECK constraint."
         },
         "examples": {
           "type": "array",
@@ -132,20 +143,20 @@
         "minLength": {
           "type": "integer",
           "minimum": 0,
-          "description": "Minimum string length (validation only, not a DB constraint)."
+          "description": "Minimum string length. Emitted as a SQLite CHECK constraint."
         },
         "maxLength": {
           "type": "integer",
           "minimum": 1,
-          "description": "Maximum string length (validation only, not a DB constraint)."
+          "description": "Maximum string length. Emitted as a SQLite CHECK constraint."
         },
         "minimum": {
           "type": "number",
-          "description": "Minimum numeric value (validation only, not a DB constraint)."
+          "description": "Minimum numeric value. Emitted as a SQLite CHECK constraint."
         },
         "maximum": {
           "type": "number",
-          "description": "Maximum numeric value (validation only, not a DB constraint)."
+          "description": "Maximum numeric value. Emitted as a SQLite CHECK constraint."
         },
         "drizzle": {
           "$ref": "#/$defs/drizzleConfig",
@@ -195,10 +206,23 @@
           "type": "string",
           "enum": ["json", "timestamp", "timestamp_ms", "boolean", "bigint"],
           "description": "Override Drizzle column mode. 'json' stores as TEXT(json), 'timestamp'/'timestamp_ms' as INTEGER, 'boolean' as INTEGER(boolean), 'bigint' as INTEGER(bigint)."
-        },
-        "customType": {
+        }
+      }
+    },
+
+    "examplePair": {
+      "type": "object",
+      "required": ["text", "output"],
+      "additionalProperties": false,
+      "properties": {
+        "text": {
           "type": "string",
-          "description": "Custom Drizzle type name (reserved for future use)."
+          "minLength": 1,
+          "description": "Source text example."
+        },
+        "output": {
+          "type": "object",
+          "description": "Expected extracted output for the source text example."
         }
       }
     },