@memberjunction/integration-schema-builder 6.1.4 → 6.2.0-edge.1

package/dist/DDLGenerator.d.ts

@@ -22,12 +22,12 @@ export declare class DDLGenerator {
      * "not sqlserver" catch-all — and the `never` default makes adding a new DatabasePlatform
      * a compile error here rather than a silent fall-through to the wrong dialect.
      */
-    private GenerateIdempotentCreateTableStatement;
+    private generateIdempotentCreateTableStatement;
     /**
      * Generate sp_addextendedproperty calls for table and column descriptions.
      */
     GenerateExtendedProperties(config: TargetTableConfig): string[];
-    private MakeColumnExtendedProperty;
+    private makeColumnExtendedProperty;
     /**
      * Wrap an sp_addextendedproperty EXEC in an existence guard so re-running a migration is
      * idempotent — without it, re-adding MS_Description to a table/column that already has it
@@ -36,7 +36,7 @@ export declare class DDLGenerator {
      * postgresql uses no extended properties here. Pass columnName=null for a table-level
      * property, or the column name for a column-level one (levels must match the EXEC).
      */
-    private GuardExtendedProperty;
+    private guardExtendedProperty;
     /**
      * Generate ALTER TABLE ADD COLUMN statement.
      */
@@ -45,7 +45,7 @@ export declare class DDLGenerator {
      * Generate ALTER TABLE ALTER COLUMN statement for type/nullability changes.
      */
     GenerateAlterTableAlterColumn(schemaName: string, tableName: string, mod: ColumnModification, platform: DatabasePlatform): string;
-    private StandardColumns;
+    private standardColumns;
 }
 /** Validates that an identifier contains only safe characters. */
 export declare function ValidateIdentifier(name: string, kind: string): void;

package/dist/DDLGenerator.js

@@ -47,7 +47,7 @@ export class DDLGenerator {
             lines.push(`    ${q(col.TargetColumnName)} ${sqlType} ${nullable}${defaultExpr}`);
         }
         // Standard integration columns (prefixed to avoid collisions)
-        lines.push(...this.StandardColumns(platform));
+        lines.push(...this.standardColumns(platform));
         // PK is SOFT-ONLY — declared in additionalSchemaInfo (which CodeGen reads to set the entity's
         // metadata PK), and emitted as NO database constraint here: not a PRIMARY KEY, and not even a
         // UNIQUE. Integration PKs are *inferred* (naming + streamed-data statistics at p<0.05), so
@@ -59,7 +59,7 @@ export class DDLGenerator {
         // Create-Tables safe even when MJ has no entity for the table yet (e.g. a prior run
         // created the table but entity generation hadn't completed), avoiding
         // "There is already an object named '<table>'" collisions.
-        const createTable = this.GenerateIdempotentCreateTableStatement(fullTable, body, platform);
+        const createTable = this.generateIdempotentCreateTableStatement(fullTable, body, platform);
         // Generate extended properties for descriptions (SQL Server only)
         if (platform === 'sqlserver') {
             const extProps = this.GenerateExtendedProperties(config);
@@ -75,7 +75,7 @@ export class DDLGenerator {
      * "not sqlserver" catch-all — and the `never` default makes adding a new DatabasePlatform
      * a compile error here rather than a silent fall-through to the wrong dialect.
      */
-    GenerateIdempotentCreateTableStatement(fullTable, body, platform) {
+    generateIdempotentCreateTableStatement(fullTable, body, platform) {
         switch (platform) {
             case 'sqlserver':
                 // Single-statement IF guard (no BEGIN/END) so RSU's batch chunking on ';\n' can't split it.
@@ -102,7 +102,7 @@ export class DDLGenerator {
                 `    @value = N'${escaped}',\n` +
                 `    @level0type = N'SCHEMA', @level0name = '${config.SchemaName}',\n` +
                 `    @level1type = N'TABLE', @level1name = '${config.TableName}';`;
-            props.push(this.GuardExtendedProperty(config.SchemaName, config.TableName, null, exec));
+            props.push(this.guardExtendedProperty(config.SchemaName, config.TableName, null, exec));
         }
         // Standard column descriptions
         const standardDescriptions = {
@@ -114,17 +114,17 @@ export class DDLGenerator {
             '__mj_integration_CustomOverflow': 'Backend staging (system) column: JSON of source fields a record returned that have no field map yet — the "extra" keys this table has no column for. A post-sync Runtime-Schema-Updation pass promotes pervasive keys to real columns and clears them here. Not user-facing metadata; transient until promotion.',
         };
         for (const [colName, desc] of Object.entries(standardDescriptions)) {
-            props.push(this.MakeColumnExtendedProperty(config.SchemaName, config.TableName, colName, desc));
+            props.push(this.makeColumnExtendedProperty(config.SchemaName, config.TableName, colName, desc));
         }
         // User-configured column descriptions
         for (const col of config.Columns) {
             if (col.Description) {
-                props.push(this.MakeColumnExtendedProperty(config.SchemaName, config.TableName, col.TargetColumnName, col.Description));
+                props.push(this.makeColumnExtendedProperty(config.SchemaName, config.TableName, col.TargetColumnName, col.Description));
             }
         }
         return props;
     }
-    MakeColumnExtendedProperty(schemaName, tableName, columnName, description) {
+    makeColumnExtendedProperty(schemaName, tableName, columnName, description) {
         const escaped = EscapeSQLString(description);
         const exec = `EXEC sp_addextendedproperty\n` +
             `    @name = N'MS_Description',\n` +
@@ -132,7 +132,7 @@ export class DDLGenerator {
             `    @level0type = N'SCHEMA', @level0name = '${schemaName}',\n` +
             `    @level1type = N'TABLE', @level1name = '${tableName}',\n` +
             `    @level2type = N'COLUMN', @level2name = '${columnName}';`;
-        return this.GuardExtendedProperty(schemaName, tableName, columnName, exec);
+        return this.guardExtendedProperty(schemaName, tableName, columnName, exec);
     }
     /**
      * Wrap an sp_addextendedproperty EXEC in an existence guard so re-running a migration is
@@ -142,7 +142,7 @@ export class DDLGenerator {
      * postgresql uses no extended properties here. Pass columnName=null for a table-level
      * property, or the column name for a column-level one (levels must match the EXEC).
      */
-    GuardExtendedProperty(schemaName, tableName, columnName, execStatement) {
+    guardExtendedProperty(schemaName, tableName, columnName, execStatement) {
         const level2 = columnName ? `N'COLUMN', N'${columnName}'` : `NULL, NULL`;
         return (`IF NOT EXISTS (SELECT 1 FROM sys.fn_listextendedproperty(` +
             `N'MS_Description', N'SCHEMA', N'${schemaName}', N'TABLE', N'${tableName}', ${level2}))\n` +
@@ -214,7 +214,7 @@ export class DDLGenerator {
             `$mj_dropviews$;`;
         return `${dropDependentViews}\n${alter}`;
     }
-    StandardColumns(platform) {
+    standardColumns(platform) {
         const q = platform === 'sqlserver' ? QuoteSqlServer : QuotePostgres;
         if (platform === 'sqlserver') {
             return [

package/dist/SchemaBuilder.d.ts

@@ -12,10 +12,10 @@ import { type RSUPipelineInput, type RSUPipelineResult } from '@memberjunction/s
  * integration-specific artifacts (sync columns, soft FKs, metadata files).
  */
 export declare class SchemaBuilder {
-    private readonly Engine;
-    private readonly SoftFKEmitter;
-    private readonly MetaEmitter;
-    private readonly Evolution;
+    private readonly engine;
+    private readonly softFKEmitter;
+    private readonly metaEmitter;
+    private readonly evolution;
     /**
      * Build all artifacts for a set of integration target tables.
      */
@@ -53,9 +53,9 @@ export declare class SchemaBuilder {
      * Convert an integration TargetTableConfig to a generic TableDefinition.
      * Adds integration-specific sync columns via AdditionalColumns.
      */
-    private ConvertToTableDefinition;
+    private convertToTableDefinition;
     /** Convert a TargetColumnConfig to a generic ColumnDefinition. */
-    private ConvertColumn;
+    private convertColumn;
     /**
      * Dialect-aware row-size guard. A dialect that reports a hard in-row size limit
      * ({@link SQLDialect.MaxInRowSizeBytes} — e.g. SQL Server's ~8060 bytes) pushes only
@@ -71,19 +71,19 @@ export declare class SchemaBuilder {
      * so there is no platform branching here. Mutates config.Columns in place to the kept subset so all
      * downstream steps (DDL, soft FK, metadata) operate on the columns that actually exist.
      */
-    private CapColumnsForRowSize;
+    private capColumnsForRowSize;
     /** Integration-specific sync columns added to every integration table. */
-    private IntegrationSyncColumns;
+    private integrationSyncColumns;
     /**
      * Extract DDL body from a wrapped migration file (strips the header comments).
      * SchemaEngine wraps DDL in a migration header — we need just the DDL
      * since we produce our own single consolidated migration file.
      */
-    private ReadFileIfExists;
-    private ValidateAccessControl;
-    private CheckCollisions;
-    private ClassifyConfigs;
-    private GetUniqueSchemas;
-    private CollectSoftFKs;
+    private readFileIfExists;
+    private validateAccessControl;
+    private checkCollisions;
+    private classifyConfigs;
+    private getUniqueSchemas;
+    private collectSoftFKs;
 }
 //# sourceMappingURL=SchemaBuilder.d.ts.map

package/dist/SchemaBuilder.js

@@ -12,10 +12,10 @@ import { GetDialect } from '@memberjunction/sql-dialect';
  */
 export class SchemaBuilder {
     constructor() {
-        this.Engine = new SchemaEngine();
-        this.SoftFKEmitter = new SoftFKConfigEmitter();
-        this.MetaEmitter = new MetadataEmitter();
-        this.Evolution = new SchemaEvolution();
+        this.engine = new SchemaEngine();
+        this.softFKEmitter = new SoftFKConfigEmitter();
+        this.metaEmitter = new MetadataEmitter();
+        this.evolution = new SchemaEvolution();
     }
     /**
      * Build all artifacts for a set of integration target tables.
@@ -29,22 +29,22 @@ export class SchemaBuilder {
             Errors: [],
         };
         // Step 1: Validate access control
-        const accessErrors = this.ValidateAccessControl(input);
+        const accessErrors = this.validateAccessControl(input);
         if (accessErrors.length > 0) {
             output.Errors.push(...accessErrors);
             return output;
         }
         // Step 2: Pre-flight collision checks
-        const collisionWarnings = this.CheckCollisions(input);
+        const collisionWarnings = this.checkCollisions(input);
         output.Warnings.push(...collisionWarnings);
         // Step 3: Separate new tables vs evolution
-        const { newConfigs, evolutionConfigs } = this.ClassifyConfigs(input);
+        const { newConfigs, evolutionConfigs } = this.classifyConfigs(input);
         // Step 4: Generate DDL using SchemaEngine
         const ddlParts = [];
         // Schema creation statements (deduplicate by schema name)
-        const schemasToCreate = this.GetUniqueSchemas(newConfigs);
+        const schemasToCreate = this.getUniqueSchemas(newConfigs);
         for (const schemaName of schemasToCreate) {
-            ddlParts.push(this.Engine.GenerateCreateSchema(schemaName, input.Platform));
+            ddlParts.push(this.engine.GenerateCreateSchema(schemaName, input.Platform));
             ddlParts.push(''); // blank line separator
         }
         // Convert new tables → TableDefinition and generate CREATE TABLE via SchemaEngine DDLGenerator
@@ -57,8 +57,8 @@ export class SchemaBuilder {
             // ~8060 bytes) makes very wide tables (600+ columns) impossible to INSERT into — cap to a
             // fitting core subset + warn, rather than emit a doomed table. No-op on dialects with no
             // in-row limit (PostgreSQL/TOAST). Mutates config.Columns.
-            output.Warnings.push(...this.CapColumnsForRowSize(config, input.Platform));
-            const tableDef = this.ConvertToTableDefinition(config, input.Platform);
+            output.Warnings.push(...this.capColumnsForRowSize(config, input.Platform));
+            const tableDef = this.convertToTableDefinition(config, input.Platform);
             // IfNotExists: integration Create-Tables must be idempotent — a physical table
             // may already exist with no MJ entity yet (e.g. a prior run created the table but
             // CodeGen hadn't created the entity), and re-running must not collide.
@@ -70,14 +70,14 @@ export class SchemaBuilder {
             const sourceObj = input.SourceSchema.Objects.find(o => o.ExternalName === config.SourceObjectName);
             if (!sourceObj)
                 continue;
-            const diff = this.Evolution.DiffSchema(sourceObj, config, existing, input.Platform);
+            const diff = this.evolution.DiffSchema(sourceObj, config, existing, input.Platform);
             if (diff.Warnings.length > 0) {
                 output.Warnings.push(...diff.Warnings);
             }
             if (diff.AddedColumns.length === 0 && diff.ModifiedColumns.length === 0 && diff.RemovedColumns.length === 0) {
                 continue; // No changes
             }
-            ddlParts.push(this.Evolution.GenerateEvolutionMigration(diff, config.SchemaName, config.TableName, input.Platform));
+            ddlParts.push(this.evolution.GenerateEvolutionMigration(diff, config.SchemaName, config.TableName, input.Platform));
             ddlParts.push(''); // blank line separator
         }
         // Emit a single migration file if there's any DDL
@@ -101,28 +101,28 @@ export class SchemaBuilder {
         }
         // Step 5: Generate soft PK and FK config
         const allConfigs = [...newConfigs, ...evolutionConfigs.map(ec => ec.config)];
-        const allSoftFKs = this.CollectSoftFKs(input, evolutionConfigs);
+        const allSoftFKs = this.collectSoftFKs(input, evolutionConfigs);
         // Always emit additionalSchemaInfo — every integration table needs a soft PK
         if (allConfigs.length > 0) {
-            const existingContent = this.ReadFileIfExists(input.AdditionalSchemaInfoPath);
-            const existingConfig = this.SoftFKEmitter.ParseExistingConfig(existingContent);
-            const withPKs = this.SoftFKEmitter.MergeSoftPKs(existingConfig, allConfigs);
+            const existingContent = this.readFileIfExists(input.AdditionalSchemaInfoPath);
+            const existingConfig = this.softFKEmitter.ParseExistingConfig(existingContent);
+            const withPKs = this.softFKEmitter.MergeSoftPKs(existingConfig, allConfigs);
             // This run's PK/FK resolution REPLACES the prior run's entries for the
             // tables it covers (adds new, removes gone) — clear their FKs before the rebuild so
             // a stale FK never outlives the resolution that once declared it. Clearing happens
             // even when allSoftFKs is empty (a table that lost every FK ends clear).
-            const cleared = this.SoftFKEmitter.ClearForeignKeysForTables(withPKs, allConfigs);
+            const cleared = this.softFKEmitter.ClearForeignKeysForTables(withPKs, allConfigs);
             const merged = allSoftFKs.length > 0
-                ? this.SoftFKEmitter.MergeSchemaConfig(cleared, allSoftFKs)
+                ? this.softFKEmitter.MergeSchemaConfig(cleared, allSoftFKs)
                 : cleared;
-            output.AdditionalSchemaInfoUpdate = this.SoftFKEmitter.EmitConfigFile(input.AdditionalSchemaInfoPath, merged);
+            output.AdditionalSchemaInfoUpdate = this.softFKEmitter.EmitConfigFile(input.AdditionalSchemaInfoPath, merged);
         }
         // Step 6: Generate metadata files for __mj entity targets
         const mjTargets = input.TargetConfigs.filter(c => c.SchemaName === '__mj');
         if (mjTargets.length > 0) {
             const entityNames = mjTargets.map(c => c.EntityName);
-            output.MetadataFiles.push(this.MetaEmitter.EmitEntitySettingsFile(entityNames, input.MetadataDir));
-            output.MetadataFiles.push(this.MetaEmitter.EmitMjSyncConfig(input.MetadataDir));
+            output.MetadataFiles.push(this.metaEmitter.EmitEntitySettingsFile(entityNames, input.MetadataDir));
+            output.MetadataFiles.push(this.metaEmitter.EmitMjSyncConfig(input.MetadataDir));
         }
         return output;
     }
@@ -216,19 +216,19 @@ export class SchemaBuilder {
      * Convert an integration TargetTableConfig to a generic TableDefinition.
      * Adds integration-specific sync columns via AdditionalColumns.
      */
-    ConvertToTableDefinition(config, platform) {
+    convertToTableDefinition(config, platform) {
         return {
             SchemaName: config.SchemaName,
             TableName: config.TableName,
             EntityName: config.EntityName,
             Description: config.Description,
-            Columns: config.Columns.map(c => this.ConvertColumn(c)),
+            Columns: config.Columns.map(c => this.convertColumn(c)),
             SoftPrimaryKeys: config.PrimaryKeyFields,
-            AdditionalColumns: this.IntegrationSyncColumns(platform),
+            AdditionalColumns: this.integrationSyncColumns(platform),
         };
     }
     /** Convert a TargetColumnConfig to a generic ColumnDefinition. */
-    ConvertColumn(col) {
+    convertColumn(col) {
         return {
             Name: col.TargetColumnName,
             Type: 'string', // Overridden by RawSqlType
@@ -256,7 +256,7 @@ export class SchemaBuilder {
      * so there is no platform branching here. Mutates config.Columns in place to the kept subset so all
      * downstream steps (DDL, soft FK, metadata) operate on the columns that actually exist.
      */
-    CapColumnsForRowSize(config, platform) {
+    capColumnsForRowSize(config, platform) {
         const dialect = GetDialect(platform);
         const maxRowBytes = dialect.MaxInRowSizeBytes;
         const maxCols = dialect.MaxColumnCount;
@@ -309,7 +309,7 @@ export class SchemaBuilder {
         ];
     }
     /** Integration-specific sync columns added to every integration table. */
-    IntegrationSyncColumns(platform) {
+    integrationSyncColumns(platform) {
         return [
             {
                 Name: '__mj_integration_SyncStatus',
@@ -405,7 +405,7 @@ export class SchemaBuilder {
      * SchemaEngine wraps DDL in a migration header — we need just the DDL
      * since we produce our own single consolidated migration file.
      */
-    ReadFileIfExists(filePath) {
+    readFileIfExists(filePath) {
         try {
             if (existsSync(filePath)) {
                 return readFileSync(filePath, 'utf-8');
@@ -415,7 +415,7 @@ export class SchemaBuilder {
         return null;
     }
     // ─── Validation & Classification ────────────────────────────────────
-    ValidateAccessControl(input) {
+    validateAccessControl(input) {
         const errors = [];
         for (const config of input.TargetConfigs) {
             if (config.SchemaName === '__mj') {
@@ -428,7 +428,7 @@ export class SchemaBuilder {
         }
         return errors;
     }
-    CheckCollisions(input) {
+    checkCollisions(input) {
         const warnings = [];
         const existingNames = new Set(input.ExistingTables.map(t => `${t.SchemaName}.${t.TableName}`.toLowerCase()));
         for (const config of input.TargetConfigs) {
@@ -439,7 +439,7 @@ export class SchemaBuilder {
         }
         return warnings;
     }
-    ClassifyConfigs(input) {
+    classifyConfigs(input) {
         const existingMap = new Map();
         for (const t of input.ExistingTables) {
             existingMap.set(`${t.SchemaName}.${t.TableName}`.toLowerCase(), t);
@@ -458,23 +458,23 @@ export class SchemaBuilder {
         }
         return { newConfigs, evolutionConfigs };
     }
-    GetUniqueSchemas(configs) {
+    getUniqueSchemas(configs) {
         const schemas = new Set();
         for (const config of configs) {
             schemas.add(config.SchemaName);
         }
         return Array.from(schemas);
     }
-    CollectSoftFKs(input, evolutionConfigs) {
+    collectSoftFKs(input, evolutionConfigs) {
         // From source relationships
-        const fromSource = this.SoftFKEmitter.GenerateConfigEntries(input.SourceSchema, input.TargetConfigs);
+        const fromSource = this.softFKEmitter.GenerateConfigEntries(input.SourceSchema, input.TargetConfigs);
         // From evolution (new FK columns)
         for (const { config, existing } of evolutionConfigs) {
             const sourceObj = input.SourceSchema.Objects.find(o => o.ExternalName === config.SourceObjectName);
             if (!sourceObj)
                 continue;
-            const diff = this.Evolution.DiffSchema(sourceObj, config, existing, input.Platform);
-            const newFKs = this.Evolution.GenerateEvolutionSoftFKUpdates(diff, config);
+            const diff = this.evolution.DiffSchema(sourceObj, config, existing, input.Platform);
+            const newFKs = this.evolution.GenerateEvolutionSoftFKUpdates(diff, config);
             fromSource.push(...newFKs);
         }
         return fromSource;

package/dist/SchemaEvolution.d.ts

@@ -8,7 +8,7 @@ import type { DatabasePlatform, ExistingTableInfo, SchemaDiff, SoftFKEntry, Sour
  */
 export declare class SchemaEvolution {
     private readonly DDL;
-    private readonly Mapper;
+    private readonly mapper;
     /**
      * Diff a source object against an existing target table.
      * Returns added, modified, and removed columns.
@@ -19,7 +19,7 @@ export declare class SchemaEvolution {
      * as ALTER-ADD configs. New tables get these in CREATE TABLE (DDLGenerator.StandardColumns);
      * existing tables created before a column was added get it ALTER-ed in here.
      */
-    private EnsureStandardColumns;
+    private ensureStandardColumns;
     /**
      * Generate ALTER TABLE SQL for a schema diff.
      */
@@ -28,6 +28,6 @@ export declare class SchemaEvolution {
      * Identify new soft FK entries from a diff (for added FK columns).
      */
     GenerateEvolutionSoftFKUpdates(diff: SchemaDiff, targetConfig: TargetTableConfig): SoftFKEntry[];
-    private HasColumnChanged;
+    private hasColumnChanged;
 }
 //# sourceMappingURL=SchemaEvolution.d.ts.map

package/dist/SchemaEvolution.js

@@ -6,7 +6,7 @@ import { TypeMapper } from './TypeMapper.js';
 export class SchemaEvolution {
     constructor() {
         this.DDL = new DDLGenerator();
-        this.Mapper = new TypeMapper();
+        this.mapper = new TypeMapper();
     }
     /**
      * Diff a source object against an existing target table.
@@ -39,7 +39,7 @@ export class SchemaEvolution {
             if (pkNames.has(lowerName)) {
                 if (existingNames.has(lowerName)) {
                     const existingCol = existing.Columns.find(c => c.Name.toLowerCase() === lowerName);
-                    if (existingCol && this.HasColumnChanged(existingCol, col)) {
+                    if (existingCol && this.hasColumnChanged(existingCol, col)) {
                         warnings.push(`PK column '${col.TargetColumnName}' type changed from ${existingCol.SqlType} to ${col.TargetSqlType} — skipped (requires manual constraint drop/recreate)`);
                     }
                 }
@@ -50,7 +50,7 @@ export class SchemaEvolution {
             }
             else {
                 const existingCol = existing.Columns.find(c => c.Name.toLowerCase() === lowerName);
-                if (existingCol && this.HasColumnChanged(existingCol, col)) {
+                if (existingCol && this.hasColumnChanged(existingCol, col)) {
                     modified.push({
                         ColumnName: col.TargetColumnName,
                         OldType: existingCol.SqlType,
@@ -74,7 +74,7 @@ export class SchemaEvolution {
         // skips standard columns (they're in `standardCols`), so a table created before a standard
         // column was introduced would never get it. ALTER-add any that are missing — otherwise the
         // engine's writes to a missing column silently no-op (hasField guard).
-        added.push(...this.EnsureStandardColumns(existing, platform));
+        added.push(...this.ensureStandardColumns(existing, platform));
         return { AddedColumns: added, ModifiedColumns: modified, RemovedColumns: removed, Warnings: warnings };
     }
     /**
@@ -82,7 +82,7 @@ export class SchemaEvolution {
      * as ALTER-ADD configs. New tables get these in CREATE TABLE (DDLGenerator.StandardColumns);
      * existing tables created before a column was added get it ALTER-ed in here.
      */
-    EnsureStandardColumns(existing, platform) {
+    ensureStandardColumns(existing, platform) {
         const have = new Set(existing.Columns.map(c => c.Name.toLowerCase()));
         const isSql = platform === 'sqlserver';
         const std = [
@@ -126,7 +126,7 @@ export class SchemaEvolution {
         const addedNames = new Set(diff.AddedColumns.map(c => c.TargetColumnName));
         return targetConfig.SoftForeignKeys.filter(fk => addedNames.has(fk.FieldName));
     }
-    HasColumnChanged(existing, target) {
+    hasColumnChanged(existing, target) {
         // Normalize types for comparison (case-insensitive, strip whitespace)
         const normalizedExisting = existing.SqlType.toLowerCase().replace(/\s+/g, '');
         const normalizedTarget = target.TargetSqlType.toLowerCase().replace(/\s+/g, '');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memberjunction/integration-schema-builder",
   "type": "module",
-  "version": "6.1.4",
+  "version": "6.2.0-edge.1",
   "description": "MemberJunction Integration Schema Builder - file-emission-only DDL generation for integration tables",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,11 +9,11 @@
     "/dist"
   ],
   "dependencies": {
-    "@memberjunction/core": "6.1.4",
-    "@memberjunction/global": "6.1.4",
-    "@memberjunction/integration-engine": "6.1.4",
-    "@memberjunction/schema-engine": "6.1.4",
-    "@memberjunction/sql-dialect": "6.1.4"
+    "@memberjunction/core": "6.2.0-edge.1",
+    "@memberjunction/global": "6.2.0-edge.1",
+    "@memberjunction/integration-engine": "6.2.0-edge.1",
+    "@memberjunction/schema-engine": "6.2.0-edge.1",
+    "@memberjunction/sql-dialect": "6.2.0-edge.1"
   },
   "devDependencies": {
     "typescript": "^5.9.3",