@createcms/core 0.1.1

package/dist/db.d.ts

@@ -0,0 +1,128 @@
+type SchemaNamespace = 'cms';
+type ColumnScalarType = 'text' | 'boolean' | 'integer' | 'timestamp' | 'jsonb' | 'tsvector';
+type ColumnType<EnumTarget extends string = string> = ColumnScalarType | {
+    enum: EnumTarget;
+};
+type DefaultValue = {
+    kind: 'literal';
+    value: boolean | number | string | string[] | Record<string, unknown>;
+} | {
+    kind: 'sql';
+    value: string;
+};
+type ForeignKeyAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
+type IndexUsing = 'btree' | 'gin';
+type ColumnDefinition<ReferenceTarget extends string = string, EnumTarget extends string = string> = {
+    type: ColumnType<EnumTarget>;
+    columnName?: string;
+    notNull?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    default?: DefaultValue;
+    defaultId?: boolean;
+    defaultIdPrefix?: string;
+    defaultNow?: boolean;
+    jsonType?: string;
+    references?: {
+        table: ReferenceTarget;
+        column: string;
+        onDelete?: ForeignKeyAction;
+        onUpdate?: ForeignKeyAction;
+    };
+};
+type TableColumns<ReferenceTarget extends string = string, EnumTarget extends string = string> = Record<string, ColumnDefinition<ReferenceTarget, EnumTarget>>;
+type IndexDefinition<ColumnName extends string> = {
+    columns: readonly ColumnName[];
+    unique?: boolean;
+    using?: IndexUsing;
+    where?: string;
+};
+type CompositePrimaryKey<ColumnName extends string> = {
+    columns: readonly ColumnName[];
+};
+type TableLevelForeignKey<ColumnName extends string = string> = {
+    columns: readonly ColumnName[];
+    foreignTable: string;
+    foreignColumns: readonly string[];
+    name?: string;
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
+};
+type TableDefinition<Columns extends TableColumns = TableColumns, ReferenceTarget extends string = string, EnumTarget extends string = string> = {
+    tableName?: string;
+    indexPrefix?: string;
+    columns: Columns;
+    indexes?: Record<string, IndexDefinition<Extract<keyof Columns, string>>>;
+    compositePrimaryKey?: CompositePrimaryKey<Extract<keyof Columns, string>>;
+    foreignKeys?: TableLevelForeignKey<Extract<keyof Columns, string>>[];
+};
+type TableExtension<ExistingColumns extends TableColumns, AddedColumns extends TableColumns> = {
+    columns: AddedColumns;
+    indexes?: Record<string, IndexDefinition<Extract<keyof ExistingColumns | keyof AddedColumns, string>>>;
+};
+type EnumDefinition = {
+    values: readonly string[];
+    enumName?: string;
+};
+type EnumMap = Record<string, EnumDefinition>;
+type TableMap = Record<string, TableDefinition>;
+type TableColumnsOf<TTable> = TTable extends TableDefinition<infer TColumns, any, any> ? TColumns : never;
+type ExtensionMap<ExistingTables extends TableMap, OwnTables extends TableMap = {}> = Partial<{
+    [K in keyof ExistingTables | keyof OwnTables]: TableExtension<TableColumnsOf<(ExistingTables & OwnTables)[K]>, TableColumns>;
+}>;
+type SchemaModule<_Namespace extends SchemaNamespace = SchemaNamespace, Tables extends TableMap = {}, Enums extends EnumMap = {}, Extensions = {}> = {
+    enums?: Enums;
+    tables?: Tables;
+    extend?: Extensions;
+};
+type ResolvedEnum = EnumDefinition & {
+    key: string;
+    dbName: string;
+};
+type ResolvedTable = {
+    key: string;
+    dbName: string;
+    indexPrefix?: string;
+    columns: TableColumns;
+    indexes: Record<string, IndexDefinition<string>>;
+    compositePrimaryKey?: CompositePrimaryKey<string>;
+    foreignKeys?: TableLevelForeignKey[];
+};
+type MergedSchema = {
+    enums: Record<string, ResolvedEnum>;
+    tables: Record<string, ResolvedTable>;
+};
+
+type SchemaInput<Tables extends TableMap, Enums extends EnumMap> = {
+    enums?: Enums;
+    tables: Tables;
+};
+declare function defineColumns<TColumns extends TableColumns>(columns: TColumns): TColumns;
+declare function defineTable<TTable extends TableDefinition>(table: TTable): TTable;
+declare function defineCoreSchema<Tables extends TableMap, Enums extends EnumMap = {}>(schema: SchemaInput<Tables, Enums>): SchemaModule<'cms', Tables, Enums> & {
+    tables: Tables;
+};
+declare function definePluginSchema<ExistingTables extends TableMap, _ExistingEnums extends EnumMap = {}, Tables extends TableMap = {}, Enums extends EnumMap = {}, Extensions extends ExtensionMap<ExistingTables, Tables> = {}>(schema: {
+    enums?: Enums;
+    tables?: Tables;
+    extend?: Extensions;
+}): SchemaModule<'cms', Tables, Enums, Extensions>;
+
+type SchemaSource = {
+    name: string;
+    schema: SchemaModule;
+};
+declare function toSnakeCase(value: string): string;
+declare function mergeSchemaSources(sources: SchemaSource[]): MergedSchema;
+
+type EmitOptions = {
+    /**
+     * Override the ID generation import statement.
+     * Defaults to `import { newId } from '@createcms/core/nanoid';`
+     */
+    nanoidImport?: string;
+};
+declare function emitDrizzleSchema(schema: MergedSchema, options?: EmitOptions): string;
+
+export { defineColumns, defineCoreSchema, definePluginSchema, defineTable, emitDrizzleSchema, mergeSchemaSources, toSnakeCase };
+export type { ColumnDefinition, ColumnScalarType, ColumnType, CompositePrimaryKey, DefaultValue, EmitOptions, EnumDefinition, EnumMap, ExtensionMap, ForeignKeyAction, IndexDefinition, MergedSchema, ResolvedEnum, ResolvedTable, SchemaModule, SchemaSource, TableColumns, TableDefinition, TableExtension, TableLevelForeignKey, TableMap };

package/dist/db.js

@@ -0,0 +1,488 @@
+function defineColumns(columns) {
+    return columns;
+}
+function defineTable(table) {
+    return table;
+}
+function defineCoreSchema(schema) {
+    return {
+        ...schema
+    };
+}
+function definePluginSchema(schema) {
+    return {
+        ...schema
+    };
+}
+
+function toSnakeCase(value) {
+    return value.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase();
+}
+function cloneColumns(columns) {
+    return Object.fromEntries(Object.entries(columns).map(([key, value])=>[
+            key,
+            {
+                ...value
+            }
+        ]));
+}
+function cloneIndexes(indexes) {
+    return Object.fromEntries(Object.entries(indexes).map(([key, value])=>[
+            key,
+            {
+                ...value,
+                columns: [
+                    ...value.columns
+                ]
+            }
+        ]));
+}
+function cloneEnum(enumDef) {
+    return {
+        ...enumDef,
+        key: '',
+        dbName: '',
+        values: [
+            ...enumDef.values
+        ]
+    };
+}
+function mergeSchemaSources(sources) {
+    const enums = {};
+    const tables = {};
+    for (const source of sources){
+        const sourceEnums = source.schema.enums ?? {};
+        for (const [enumKey, enumDef] of Object.entries(sourceEnums)){
+            if (enums[enumKey]) {
+                throw new Error(`Duplicate enum "${enumKey}" declared by "${source.name}".`);
+            }
+            const resolved = cloneEnum(enumDef);
+            resolved.key = enumKey;
+            resolved.dbName = enumDef.enumName ?? toSnakeCase(enumKey);
+            enums[enumKey] = resolved;
+        }
+        const sourceTables = source.schema.tables ?? {};
+        for (const [tableKey, tableDef] of Object.entries(sourceTables)){
+            if (tables[tableKey]) {
+                throw new Error(`Duplicate table "${tableKey}" declared by "${source.name}".`);
+            }
+            const resolved = {
+                key: tableKey,
+                dbName: tableDef.tableName ?? toSnakeCase(tableKey),
+                indexPrefix: tableDef.indexPrefix,
+                columns: cloneColumns(tableDef.columns),
+                indexes: cloneIndexes(Object.fromEntries(Object.entries(tableDef.indexes ?? {}).map(([indexKey, indexDef])=>[
+                        indexKey,
+                        {
+                            ...indexDef,
+                            columns: [
+                                ...indexDef.columns
+                            ]
+                        }
+                    ]))),
+                compositePrimaryKey: tableDef.compositePrimaryKey ? {
+                    columns: [
+                        ...tableDef.compositePrimaryKey.columns
+                    ]
+                } : undefined,
+                foreignKeys: tableDef.foreignKeys ? tableDef.foreignKeys.map((fk)=>({
+                        ...fk,
+                        columns: [
+                            ...fk.columns
+                        ],
+                        foreignColumns: [
+                            ...fk.foreignColumns
+                        ]
+                    })) : undefined
+            };
+            tables[tableKey] = resolved;
+        }
+    }
+    // Phase 2: Apply extensions
+    for (const source of sources){
+        const sourceExtensions = source.schema.extend ?? {};
+        for (const [targetTableKey, extension] of Object.entries(sourceExtensions)){
+            const targetTable = tables[targetTableKey];
+            if (!targetTable) {
+                throw new Error(`Schema source "${source.name}" extends unknown table "${targetTableKey}".`);
+            }
+            for (const [columnKey, columnDef] of Object.entries(extension.columns)){
+                if (targetTable.columns[columnKey]) {
+                    throw new Error(`Schema source "${source.name}" tried to add duplicate column "${columnKey}" to "${targetTableKey}".`);
+                }
+                targetTable.columns[columnKey] = {
+                    ...columnDef
+                };
+            }
+            for (const [indexKey, indexDef] of Object.entries(extension.indexes ?? {})){
+                if (targetTable.indexes[indexKey]) {
+                    throw new Error(`Schema source "${source.name}" tried to add duplicate index "${indexKey}" to "${targetTableKey}".`);
+                }
+                targetTable.indexes[indexKey] = {
+                    ...indexDef,
+                    columns: [
+                        ...indexDef.columns
+                    ]
+                };
+            }
+        }
+    }
+    // Phase 3: Validation
+    const enumDbNames = new Set();
+    for (const enumDef of Object.values(enums)){
+        if (enumDbNames.has(enumDef.dbName)) {
+            throw new Error(`Duplicate enum database name "${enumDef.dbName}".`);
+        }
+        enumDbNames.add(enumDef.dbName);
+    }
+    const tableDbNames = new Set();
+    for (const table of Object.values(tables)){
+        if (tableDbNames.has(table.dbName)) {
+            throw new Error(`Duplicate table database name "${table.dbName}".`);
+        }
+        tableDbNames.add(table.dbName);
+        for (const [columnKey, columnDef] of Object.entries(table.columns)){
+            if (typeof columnDef.type === 'object') {
+                const enumName = columnDef.type.enum;
+                if (!enums[enumName]) {
+                    throw new Error(`Column "${table.key}.${columnKey}" references unknown enum "${enumName}".`);
+                }
+            }
+            if (columnDef.references) {
+                const referencedTable = tables[columnDef.references.table];
+                if (!referencedTable) {
+                    throw new Error(`Column "${table.key}.${columnKey}" references unknown table "${columnDef.references.table}".`);
+                }
+                if (!referencedTable.columns[columnDef.references.column]) {
+                    throw new Error(`Column "${table.key}.${columnKey}" references unknown column "${columnDef.references.table}.${columnDef.references.column}".`);
+                }
+            }
+        }
+        for (const [indexKey, indexDef] of Object.entries(table.indexes)){
+            for (const columnName of indexDef.columns){
+                if (!table.columns[columnName]) {
+                    throw new Error(`Index "${table.key}.${indexKey}" references unknown column "${columnName}".`);
+                }
+            }
+        }
+        if (table.foreignKeys) {
+            for (const fk of table.foreignKeys){
+                for (const col of fk.columns){
+                    if (!table.columns[col]) {
+                        throw new Error(`Foreign key in "${table.key}" references unknown local column "${col}".`);
+                    }
+                }
+                const refTable = tables[fk.foreignTable];
+                if (!refTable) {
+                    throw new Error(`Foreign key in "${table.key}" references unknown table "${fk.foreignTable}".`);
+                }
+                for (const col of fk.foreignColumns){
+                    if (!refTable.columns[col]) {
+                        throw new Error(`Foreign key in "${table.key}" references unknown column "${fk.foreignTable}.${col}".`);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        enums,
+        tables
+    };
+}
+
+function quote(value) {
+    return JSON.stringify(value);
+}
+function toPascalCase(value) {
+    return value.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_\-\s]+/g, ' ').split(' ').filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
+}
+function singularize(value) {
+    if (value.endsWith('ies')) {
+        return `${value.slice(0, -3)}y`;
+    }
+    if (value.endsWith('ches') || value.endsWith('shes') || value.endsWith('xes') || value.endsWith('zes')) {
+        return value.slice(0, -2);
+    }
+    if (value.endsWith('s') && !value.endsWith('ss')) {
+        return value.slice(0, -1);
+    }
+    return value;
+}
+function emitLiteral(value) {
+    return JSON.stringify(value.value);
+}
+function emitDefault(defaultValue) {
+    switch(defaultValue.kind){
+        case 'literal':
+            return {
+                code: `.default(${emitLiteral(defaultValue)})`,
+                needsSql: false
+            };
+        case 'sql':
+            return {
+                code: `.default(sql.raw(${quote(defaultValue.value)}))`,
+                needsSql: true
+            };
+    }
+}
+function emitEnum(enumDef) {
+    const values = `[${enumDef.values.map(quote).join(', ')}]`;
+    return `export const ${enumDef.key}Enum = cms.enum(${quote(enumDef.dbName)}, ${values});`;
+}
+function emitColumn(table, columnKey, columnDef) {
+    const columnName = columnDef.columnName ?? toSnakeCase(columnKey);
+    let builder = '';
+    let needsTsvector = false;
+    if (typeof columnDef.type === 'string') {
+        if (columnDef.type === 'tsvector') {
+            builder = `tsvectorColumn(${quote(columnName)})`;
+            needsTsvector = true;
+        } else {
+            builder = `${columnDef.type}(${quote(columnName)})`;
+        }
+    } else {
+        builder = `${columnDef.type.enum}Enum(${quote(columnName)})`;
+    }
+    let needsSql = false;
+    let needsAnyPgColumn = false;
+    if (columnDef.jsonType && typeof columnDef.type === 'string' && columnDef.type === 'jsonb') {
+        builder += `.$type<${columnDef.jsonType}>()`;
+    }
+    if (columnDef.primaryKey) {
+        builder += '.primaryKey()';
+    }
+    if (columnDef.notNull) {
+        builder += '.notNull()';
+    }
+    if (columnDef.unique) {
+        builder += '.unique()';
+    }
+    if (columnDef.defaultNow) {
+        builder += '.defaultNow()';
+    }
+    if (columnDef.defaultId) {
+        if (!columnDef.defaultIdPrefix) {
+            throw new Error(`Column "${columnKey}" has defaultId but no defaultIdPrefix`);
+        }
+        builder += `.$defaultFn(() => newId(${quote(columnDef.defaultIdPrefix)}))`;
+    }
+    if (columnDef.default) {
+        const emitted = emitDefault(columnDef.default);
+        builder += emitted.code;
+        needsSql ||= emitted.needsSql;
+    }
+    if (columnDef.references) {
+        const options = [];
+        if (columnDef.references.onDelete) {
+            options.push(`onDelete: ${quote(columnDef.references.onDelete)}`);
+        }
+        if (columnDef.references.onUpdate) {
+            options.push(`onUpdate: ${quote(columnDef.references.onUpdate)}`);
+        }
+        const suffix = options.length > 0 ? `, { ${options.join(', ')} }` : '';
+        const isSelfReference = columnDef.references.table === table.key;
+        const refCallback = isSelfReference ? `(): AnyPgColumn => ${columnDef.references.table}.${columnDef.references.column}` : `() => ${columnDef.references.table}.${columnDef.references.column}`;
+        needsAnyPgColumn ||= isSelfReference;
+        builder += `.references(${refCallback}${suffix})`;
+    }
+    return {
+        code: `    ${columnKey}: ${builder},`,
+        needsSql,
+        needsAnyPgColumn,
+        needsTsvector
+    };
+}
+function emitIndexes(table) {
+    const entries = Object.entries(table.indexes);
+    if (entries.length === 0) {
+        return [];
+    }
+    const prefix = table.indexPrefix ?? table.dbName;
+    return entries.map(([indexKey, indexDef])=>{
+        const factory = indexDef.unique ? 'uniqueIndex' : 'index';
+        const columns = indexDef.columns.map((column)=>`table.${column}`).join(', ');
+        let line;
+        if (indexDef.using && indexDef.using !== 'btree') {
+            line = `    ${factory}(${quote(`${prefix}_${toSnakeCase(indexKey)}`)}).using(${quote(indexDef.using)}, ${columns})`;
+        } else {
+            line = `    ${factory}(${quote(`${prefix}_${toSnakeCase(indexKey)}`)}).on(${columns})`;
+        }
+        if (indexDef.where) {
+            line += `.where(sql\`${indexDef.where}\`)`;
+        }
+        return `${line},`;
+    });
+}
+function emitCompositePrimaryKey(table) {
+    if (!table.compositePrimaryKey) return null;
+    const columns = table.compositePrimaryKey.columns.map((col)=>`table.${col}`).join(', ');
+    return `    primaryKey({ columns: [${columns}] }),`;
+}
+function emitTableLevelForeignKeys(table) {
+    if (!table.foreignKeys || table.foreignKeys.length === 0) {
+        return {
+            lines: [],
+            needsForeignKeyImport: false
+        };
+    }
+    const lines = table.foreignKeys.map((fk)=>{
+        const localCols = fk.columns.map((c)=>`table.${c}`).join(', ');
+        const isSelfReference = fk.foreignTable === table.key;
+        const foreignCols = fk.foreignColumns.map((c)=>`${isSelfReference ? 'table' : fk.foreignTable}.${c}`).join(', ');
+        const parts = [
+            `      columns: [${localCols}],`,
+            `      foreignColumns: [${foreignCols}],`
+        ];
+        if (fk.name) {
+            parts.push(`      name: ${quote(fk.name)},`);
+        }
+        let chain = '';
+        if (fk.onDelete) {
+            chain += `.onDelete(${quote(fk.onDelete)})`;
+        }
+        if (fk.onUpdate) {
+            chain += `.onUpdate(${quote(fk.onUpdate)})`;
+        }
+        return `    foreignKey({\n${parts.join('\n')}\n    })${chain},`;
+    });
+    return {
+        lines,
+        needsForeignKeyImport: true
+    };
+}
+function emitTableTypeAliases(table) {
+    const baseName = toPascalCase(singularize(table.key));
+    return `export type ${baseName} = typeof ${table.key}.$inferSelect;
+export type New${baseName} = typeof ${table.key}.$inferInsert;`;
+}
+function emitTable(table) {
+    let needsSql = false;
+    let needsAnyPgColumn = false;
+    let needsForeignKeyImport = false;
+    let needsPrimaryKeyImport = false;
+    let needsTsvector = false;
+    const emittedColumns = Object.entries(table.columns).map(([columnKey, columnDef])=>{
+        const emitted = emitColumn(table, columnKey, columnDef);
+        needsSql ||= emitted.needsSql;
+        needsAnyPgColumn ||= emitted.needsAnyPgColumn;
+        needsTsvector ||= emitted.needsTsvector;
+        return emitted.code;
+    });
+    const indexes = emitIndexes(table);
+    for (const idx of Object.values(table.indexes)){
+        if (idx.where) needsSql = true;
+    }
+    const compositePK = emitCompositePrimaryKey(table);
+    if (compositePK) needsPrimaryKeyImport = true;
+    const { lines: fkLines, needsForeignKeyImport: needsFK } = emitTableLevelForeignKeys(table);
+    needsForeignKeyImport = needsFK;
+    const tableFactory = 'cms.table';
+    const callbackLines = [
+        ...compositePK ? [
+            compositePK
+        ] : [],
+        ...fkLines,
+        ...indexes
+    ];
+    const callback = callbackLines.length > 0 ? `,
+  (table) => [
+${callbackLines.join('\n')}
+  ]` : '';
+    return {
+        code: `export const ${table.key} = ${tableFactory}(
+  ${quote(table.dbName)},
+  {
+${emittedColumns.join('\n')}
+  }${callback},
+);`,
+        needsSql,
+        needsAnyPgColumn,
+        needsForeignKeyImport,
+        needsPrimaryKeyImport,
+        needsTsvector
+    };
+}
+function emitDrizzleSchema(schema, options) {
+    const pgCoreImports = new Set([
+        'pgSchema'
+    ]);
+    let needsSql = false;
+    let needsAnyPgColumn = false;
+    let needsForeignKeyImport = false;
+    let needsPrimaryKeyImport = false;
+    let needsTsvector = false;
+    const enums = Object.values(schema.enums).sort((a, b)=>a.key.localeCompare(b.key));
+    const tables = Object.values(schema.tables).sort((a, b)=>a.key.localeCompare(b.key));
+    for (const table of tables){
+        for (const column of Object.values(table.columns)){
+            if (typeof column.type === 'string') {
+                if (column.type !== 'tsvector') {
+                    pgCoreImports.add(column.type);
+                }
+            }
+            if (column.default?.kind === 'sql') {
+                needsSql = true;
+            }
+        }
+        if (Object.keys(table.indexes).length > 0) {
+            pgCoreImports.add('index');
+        }
+        if (Object.values(table.indexes).some((indexDef)=>indexDef.unique)) {
+            pgCoreImports.add('uniqueIndex');
+        }
+        if (Object.values(table.indexes).some((indexDef)=>indexDef.where)) {
+            needsSql = true;
+        }
+    }
+    const enumBlocks = enums.map(emitEnum);
+    const tableBlocks = tables.map((table)=>{
+        const emitted = emitTable(table);
+        needsSql ||= emitted.needsSql;
+        needsAnyPgColumn ||= emitted.needsAnyPgColumn;
+        needsForeignKeyImport ||= emitted.needsForeignKeyImport;
+        needsPrimaryKeyImport ||= emitted.needsPrimaryKeyImport;
+        needsTsvector ||= emitted.needsTsvector;
+        return emitted.code;
+    });
+    const typeBlocks = tables.map(emitTableTypeAliases);
+    if (needsForeignKeyImport) pgCoreImports.add('foreignKey');
+    if (needsPrimaryKeyImport) pgCoreImports.add('primaryKey');
+    if (needsTsvector) pgCoreImports.add('customType');
+    const imports = [];
+    if (needsSql) {
+        imports.push(`import { sql } from 'drizzle-orm';`);
+    }
+    imports.push(`import { ${Array.from(pgCoreImports).sort().join(', ')} } from 'drizzle-orm/pg-core';`);
+    if (needsAnyPgColumn) {
+        imports.push(`import type { AnyPgColumn } from 'drizzle-orm/pg-core';`);
+    }
+    const needsNewId = tables.some((table)=>Object.values(table.columns).some((col)=>col.defaultId));
+    if (needsNewId) {
+        imports.push(options?.nanoidImport ?? `import { newId } from '@createcms/core/nanoid';`);
+    }
+    const tsvectorDef = needsTsvector ? `\nconst tsvectorColumn = customType<{ data: string }>({
+  dataType() { return 'tsvector'; },
+});\n` : '';
+    const schemaExport = `export const schema = {
+${tables.map((table)=>`  ${table.key},`).join('\n')}
+${enums.map((enumDef)=>`  ${enumDef.key}Enum,`).join('\n')}
+};`;
+    return `/* eslint-disable */
+/**
+ * This file is generated by createcms.
+ * Do not edit manually.
+ */
+
+${imports.join('\n')}
+
+export const cms = pgSchema('cms');
+${tsvectorDef}${enumBlocks.join('\n\n')}
+${enumBlocks.length > 0 && tableBlocks.length > 0 ? '\n' : ''}${tableBlocks.join('\n\n')}
+
+${schemaExport}
+
+${typeBlocks.join('\n\n')}
+`;
+}
+
+export { defineColumns, defineCoreSchema, definePluginSchema, defineTable, emitDrizzleSchema, mergeSchemaSources, toSnakeCase };