relq 1.0.24 → 1.0.26

package/dist/esm/schema-definition/pg-trigger.js

@@ -92,6 +92,45 @@ export function pgTrigger(name, options) {
         $triggerName: name,
         $options: options,
         $type: 'trigger',
+        $trackingId: undefined,
+        toAST() {
+            const opts = this.$options;
+            let timing;
+            let events;
+            if (opts.before) {
+                timing = 'BEFORE';
+                events = Array.isArray(opts.before) ? opts.before : [opts.before];
+            }
+            else if (opts.after) {
+                timing = 'AFTER';
+                events = Array.isArray(opts.after) ? opts.after : [opts.after];
+            }
+            else if (opts.insteadOf) {
+                timing = 'INSTEAD OF';
+                events = Array.isArray(opts.insteadOf) ? opts.insteadOf : [opts.insteadOf];
+            }
+            else {
+                timing = 'BEFORE';
+                events = ['INSERT'];
+            }
+            const forEach = opts.forEachStatement ? 'STATEMENT' : 'ROW';
+            const functionName = typeof opts.execute === 'string'
+                ? opts.execute
+                : opts.execute.$functionName;
+            return {
+                name: this.$triggerName,
+                table: getTableName(opts.on),
+                timing,
+                events,
+                forEach,
+                functionName,
+                whenClause: opts.when,
+                isConstraint: opts.constraint ?? false,
+                deferrable: opts.deferrable,
+                initiallyDeferred: opts.initially === 'DEFERRED',
+                trackingId: this.$trackingId,
+            };
+        },
     };
 }
 export function isTriggerConfig(value) {

package/dist/esm/schema-definition/pg-view.js

@@ -4,6 +4,14 @@ export function pgView(name, definition) {
         name,
         definition: definition.trim(),
         isMaterialized: false,
+        toAST() {
+            return {
+                name: this.name,
+                definition: this.definition,
+                isMaterialized: false,
+                trackingId: this.$trackingId,
+            };
+        },
     };
 }
 export function pgMaterializedView(name, definition, options) {
@@ -13,6 +21,15 @@ export function pgMaterializedView(name, definition, options) {
         definition: definition.trim(),
         isMaterialized: true,
         withData: options?.withData,
+        toAST() {
+            return {
+                name: this.name,
+                definition: this.definition,
+                isMaterialized: true,
+                withData: this.withData,
+                trackingId: this.$trackingId,
+            };
+        },
     };
 }
 export function viewToSQL(view) {

package/dist/esm/schema-definition/sql-expressions.js

@@ -179,6 +179,9 @@ export function pgExtensions(...extensions) {
         toSQL() {
             return extensions.map(ext => `CREATE EXTENSION IF NOT EXISTS "${ext}";`);
         },
+        toAST() {
+            return [...extensions];
+        },
     };
 }
 export function getSql(expr) {

package/dist/esm/schema-definition/table-definition.js

@@ -1,6 +1,7 @@
 import format from "../addon/pg-format/index.js";
 import { partitionStrategyFactory } from "./partitions.js";
 import { sqlFunctions, expressionBuilder } from "./sql-expressions.js";
+import { tableToAST } from "../cli/utils/schema-to-ast.js";
 function formatWhereValue(val) {
     if (val === null)
         return 'NULL';
@@ -475,6 +476,9 @@ export function defineTable(name, columns, options) {
         },
         toCreateIndexSQL() {
             return generateIndexSQL(this);
+        },
+        toAST() {
+            return tableToAST(this);
         }
     };
     return definition;

package/dist/index.d.ts

@@ -199,6 +199,102 @@ export interface DefaultValue {
 	readonly $sql: string;
 	readonly $isDefault: true;
 }
+/**
+ * AST Type Definitions
+ *
+ * Type definitions for parsed PostgreSQL schema objects.
+ * These are intermediate representations between pgsql-parser AST and TypeScript code generation.
+ */
+export interface ParsedColumn {
+	name: string;
+	type: string;
+	typeParams?: {
+		precision?: number;
+		scale?: number;
+		length?: number;
+	};
+	isNullable: boolean;
+	isPrimaryKey: boolean;
+	isUnique: boolean;
+	hasDefault: boolean;
+	defaultValue?: string;
+	isGenerated: boolean;
+	generatedExpression?: string;
+	generatedExpressionAst?: any;
+	checkConstraint?: {
+		name: string;
+		expression: string;
+		expressionAst?: any;
+	};
+	references?: {
+		table: string;
+		column: string;
+		onDelete?: string;
+		onUpdate?: string;
+		match?: "SIMPLE" | "FULL";
+		deferrable?: boolean;
+		initiallyDeferred?: boolean;
+	};
+	isArray: boolean;
+	arrayDimensions?: number;
+	comment?: string;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedConstraint {
+	name: string;
+	type: "PRIMARY KEY" | "UNIQUE" | "FOREIGN KEY" | "CHECK" | "EXCLUDE";
+	columns: string[];
+	expression?: string;
+	expressionAst?: any;
+	comment?: string;
+	references?: {
+		table: string;
+		columns: string[];
+		onDelete?: string;
+		onUpdate?: string;
+		match?: "SIMPLE" | "FULL";
+		deferrable?: boolean;
+		initiallyDeferred?: boolean;
+	};
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedIndex {
+	name: string;
+	columns: string[];
+	isUnique: boolean;
+	method?: string;
+	whereClause?: string;
+	whereClauseAst?: any;
+	includeColumns?: string[];
+	opclass?: string;
+	isExpression?: boolean;
+	expressions?: string[];
+	comment?: string;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedTable {
+	name: string;
+	schema?: string;
+	columns: ParsedColumn[];
+	constraints: ParsedConstraint[];
+	indexes: ParsedIndex[];
+	isPartitioned: boolean;
+	partitionType?: "RANGE" | "LIST" | "HASH";
+	partitionKey?: string[];
+	partitionOf?: string;
+	partitionBound?: string;
+	inherits?: string[];
+	comment?: string;
+	childPartitions?: {
+		name: string;
+		partitionBound: string;
+	}[];
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
 declare const EMPTY_OBJECT: unique symbol;
 declare const EMPTY_ARRAY: unique symbol;
 export interface ColumnConfig<T = unknown> {
@@ -443,6 +539,8 @@ export interface TableDefinition<T extends Record<string, ColumnConfig>> {
 	$inferInsert: BuildInsertType<T>;
 	toSQL(): string;
 	toCreateIndexSQL(): string[];
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedTable;
 }
 /**
  * Infer TypeScript type from a ColumnConfig

package/dist/schema-builder.d.ts

@@ -72,6 +72,192 @@ export declare const DEFAULT: {
 	readonly money: (value: number | string) => DefaultValue;
 	readonly zeroMoney: () => DefaultValue;
 };
+/**
+ * AST Type Definitions
+ *
+ * Type definitions for parsed PostgreSQL schema objects.
+ * These are intermediate representations between pgsql-parser AST and TypeScript code generation.
+ */
+export interface ParsedColumn {
+	name: string;
+	type: string;
+	typeParams?: {
+		precision?: number;
+		scale?: number;
+		length?: number;
+	};
+	isNullable: boolean;
+	isPrimaryKey: boolean;
+	isUnique: boolean;
+	hasDefault: boolean;
+	defaultValue?: string;
+	isGenerated: boolean;
+	generatedExpression?: string;
+	generatedExpressionAst?: any;
+	checkConstraint?: {
+		name: string;
+		expression: string;
+		expressionAst?: any;
+	};
+	references?: {
+		table: string;
+		column: string;
+		onDelete?: string;
+		onUpdate?: string;
+		match?: "SIMPLE" | "FULL";
+		deferrable?: boolean;
+		initiallyDeferred?: boolean;
+	};
+	isArray: boolean;
+	arrayDimensions?: number;
+	comment?: string;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedConstraint {
+	name: string;
+	type: "PRIMARY KEY" | "UNIQUE" | "FOREIGN KEY" | "CHECK" | "EXCLUDE";
+	columns: string[];
+	expression?: string;
+	expressionAst?: any;
+	comment?: string;
+	references?: {
+		table: string;
+		columns: string[];
+		onDelete?: string;
+		onUpdate?: string;
+		match?: "SIMPLE" | "FULL";
+		deferrable?: boolean;
+		initiallyDeferred?: boolean;
+	};
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedIndex {
+	name: string;
+	columns: string[];
+	isUnique: boolean;
+	method?: string;
+	whereClause?: string;
+	whereClauseAst?: any;
+	includeColumns?: string[];
+	opclass?: string;
+	isExpression?: boolean;
+	expressions?: string[];
+	comment?: string;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedTable {
+	name: string;
+	schema?: string;
+	columns: ParsedColumn[];
+	constraints: ParsedConstraint[];
+	indexes: ParsedIndex[];
+	isPartitioned: boolean;
+	partitionType?: "RANGE" | "LIST" | "HASH";
+	partitionKey?: string[];
+	partitionOf?: string;
+	partitionBound?: string;
+	inherits?: string[];
+	comment?: string;
+	childPartitions?: {
+		name: string;
+		partitionBound: string;
+	}[];
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedEnum {
+	name: string;
+	schema?: string;
+	values: string[];
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedDomain {
+	name: string;
+	schema?: string;
+	baseType: string;
+	notNull: boolean;
+	defaultValue?: string;
+	checkExpression?: string;
+	checkName?: string;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedView {
+	name: string;
+	schema?: string;
+	definition: string;
+	isMaterialized: boolean;
+	/** For materialized views: WITH DATA or WITH NO DATA */
+	withData?: boolean;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedFunction {
+	name: string;
+	schema?: string;
+	args: {
+		name?: string;
+		type: string;
+		mode?: string;
+		default?: string;
+	}[];
+	returnType: string;
+	language: string;
+	body: string;
+	volatility?: "VOLATILE" | "STABLE" | "IMMUTABLE";
+	isStrict: boolean;
+	securityDefiner: boolean;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedTrigger {
+	name: string;
+	table: string;
+	timing: "BEFORE" | "AFTER" | "INSTEAD OF";
+	events: ("INSERT" | "UPDATE" | "DELETE" | "TRUNCATE")[];
+	forEach: "ROW" | "STATEMENT";
+	functionName: string;
+	whenClause?: string;
+	isConstraint: boolean;
+	deferrable?: boolean;
+	initiallyDeferred?: boolean;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedSequence {
+	name: string;
+	schema?: string;
+	startValue?: number;
+	increment?: number;
+	minValue?: number;
+	maxValue?: number;
+	cache?: number;
+	cycle: boolean;
+	ownedBy?: {
+		table: string;
+		column: string;
+	};
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+/**
+ * Composite type (CREATE TYPE ... AS)
+ */
+export interface ParsedCompositeType {
+	name: string;
+	schema?: string;
+	attributes: Array<{
+		name: string;
+		type: string;
+		collation?: string;
+	}>;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
 export declare const EMPTY_OBJECT: unique symbol;
 export declare const EMPTY_ARRAY: unique symbol;
 export interface ColumnConfig<T = unknown> {
@@ -830,6 +1016,9 @@ export interface DomainConfig<T> {
 	$collation?: string;
 	/** Base ColumnBuilder for type inference */
 	$columnBuilder?: ColumnBuilder<T>;
+	$trackingId?: string;
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedDomain;
 }
 /**
  * Domain check condition - represents a CHECK constraint expression
@@ -1005,6 +1194,9 @@ export interface CompositeTypeConfig<T extends Record<string, ColumnConfig>> {
 	$inferType: {
 		[K in keyof T]: T[K] extends ColumnConfig<infer U> ? U : unknown;
 	};
+	$trackingId?: string;
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedCompositeType;
 }
 /**
  * Define a PostgreSQL composite type
@@ -1536,6 +1728,8 @@ export interface PgExtensionsConfig {
 	extensions: readonly PgExtension[];
 	/** Generate CREATE EXTENSION SQL */
 	toSQL(): string[];
+	/** Returns extension names for schema diffing */
+	toAST(): string[];
 }
 /**
  * Define PostgreSQL extensions for your database
@@ -2385,9 +2579,11 @@ export interface TableDefinition<T extends Record<string, ColumnConfig>> {
 	$inferInsert: BuildInsertType<T>;
 	toSQL(): string;
 	toCreateIndexSQL(): string[];
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedTable;
 }
 export declare function defineTable<T extends Record<string, ColumnConfig>>(name: string, columns: T, options?: Partial<Omit<TableConfig<T>, "columns">>): TableDefinition<T>;
-export interface ParsedColumn {
+interface ParsedColumn$1 {
 	name: string;
 	type: string;
 	nullable: boolean;
@@ -2408,10 +2604,10 @@ export interface ParsedColumn {
 	array: boolean;
 	arrayDimensions: number;
 }
-export interface ParsedTable {
+interface ParsedTable$1 {
 	name: string;
 	schema?: string;
-	columns: ParsedColumn[];
+	columns: ParsedColumn$1[];
 	primaryKey?: string[];
 	uniqueConstraints: Array<{
 		columns: string[];
@@ -2432,16 +2628,16 @@ export interface ParsedTable {
 		name?: string;
 	}>;
 }
-export declare function parseCreateTable(sql: string): ParsedTable;
-export declare function generateSchemaCode(table: ParsedTable, options?: {
+export declare function parseCreateTable(sql: string): ParsedTable$1;
+export declare function generateSchemaCode(table: ParsedTable$1, options?: {
 	exportName?: string;
 }): string;
 export declare function introspectSQL(sql: string): {
-	parsed: ParsedTable;
+	parsed: ParsedTable$1;
 	code: string;
 };
 export declare function introspectMultiple(sql: string): Array<{
-	parsed: ParsedTable;
+	parsed: ParsedTable$1;
 	code: string;
 }>;
 export interface RelationConfig {
@@ -3009,6 +3205,7 @@ export interface PgEnumConfig<T extends readonly string[]> {
 	$enumName: string;
 	/** Allowed values */
 	$enumValues: T;
+	$trackingId?: string;
 	/** Creates a column using this enum type */
 	(columnName?: string): ColumnBuilder<T[number]> & {
 		$enumName: string;
@@ -3021,6 +3218,8 @@ export interface PgEnumConfig<T extends readonly string[]> {
 	name: string;
 	/** Check if value is valid enum member (type guard) */
 	includes(value: unknown): value is T[number];
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedEnum;
 }
 /**
  * Create a PostgreSQL ENUM type
@@ -3056,12 +3255,6 @@ export declare function addEnumValueSQL(enumName: string, newValue: string, posi
 	before?: string;
 	after?: string;
 }): string;
-/**
- * PostgreSQL Function Definition for Schema Builder
- *
- * Provides type-safe function definitions that can be used in schema.ts
- * and referenced by triggers.
- */
 export type FunctionVolatility = "VOLATILE" | "STABLE" | "IMMUTABLE";
 export type FunctionParallel = "UNSAFE" | "RESTRICTED" | "SAFE";
 export type FunctionSecurity = "INVOKER" | "DEFINER";
@@ -3117,6 +3310,9 @@ export interface FunctionConfig {
 	$options: FunctionOptions;
 	/** Marker for function type */
 	$type: "function";
+	$trackingId?: string;
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedFunction;
 }
 /**
  * Generate SQL for a function definition
@@ -3260,6 +3456,9 @@ export interface TriggerConfig<TTable = unknown> {
 	$options: TriggerOptions<TTable>;
 	/** Marker for trigger type */
 	$type: "trigger";
+	$trackingId?: string;
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedTrigger;
 }
 /**
  * Generate SQL for a trigger definition
@@ -3337,12 +3536,6 @@ export declare function pgTrigger<TTable = unknown>(name: string, options: Trigg
  * Check if a value is a TriggerConfig
  */
 export declare function isTriggerConfig(value: unknown): value is TriggerConfig;
-/**
- * PostgreSQL Sequence Definition for Schema Builder
- *
- * Provides type-safe sequence definitions that can be used in schema.ts
- * and referenced by column defaults.
- */
 export interface SequenceOptions {
 	/** Data type: smallint, integer (default), or bigint */
 	as?: "smallint" | "integer" | "bigint";
@@ -3365,6 +3558,9 @@ export interface SequenceConfig {
 	readonly _type: "sequence";
 	readonly name: string;
 	readonly options: SequenceOptions;
+	$trackingId?: string;
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedSequence;
 }
 /**
  * Define a PostgreSQL sequence
@@ -3407,16 +3603,14 @@ export declare function dropSequenceSQL(seq: SequenceConfig): string;
  * Type guard to check if a value is a SequenceConfig
  */
 export declare function isSequenceConfig(value: unknown): value is SequenceConfig;
-/**
- * PostgreSQL View Definitions
- *
- * Provides typed helpers for defining views and materialized views.
- */
 export interface ViewConfig {
 	_type: "view";
 	name: string;
 	definition: string;
 	isMaterialized: false;
+	$trackingId?: string;
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedView;
 }
 export interface MaterializedViewConfig {
 	_type: "materialized_view";
@@ -3424,6 +3618,9 @@ export interface MaterializedViewConfig {
 	definition: string;
 	isMaterialized: true;
 	withData?: boolean;
+	$trackingId?: string;
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedView;
 }
 /**
  * Define a PostgreSQL view
@@ -3560,6 +3757,8 @@ export {
 	FunctionOptions$1 as FunctionOptions,
 	FunctionSecurity$1 as FunctionSecurity,
 	FunctionVolatility$1 as FunctionVolatility,
+	ParsedColumn$1 as ParsedColumn,
+	ParsedTable$1 as ParsedTable,
 };
 
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relq",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "The Fully-Typed PostgreSQL ORM for TypeScript",
   "author": "Olajide Mathew O. <olajide.mathew@yuniq.solutions>",
   "license": "MIT",