@prisma-next/psl-printer 0.5.0-dev.8 → 0.5.0-dev.80

package/src/raw-default-parser.ts

@@ -1,98 +0,0 @@
-import type { ColumnDefault } from '@prisma-next/contract/types';
-
-/**
- * Parses a raw database default expression into a normalized ColumnDefault.
- * When nativeType is provided, parsing can preserve Postgres semantics for
- * timestamp and JSON defaults that would otherwise be ambiguous.
- */
-
-const NEXTVAL_PATTERN = /^nextval\s*\(/i;
-const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const JSON_CAST_SUFFIX = /::jsonb?$/i;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-
-function canonicalizeTimestampDefault(expr: string): string | undefined {
-  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';
-  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';
-
-  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;
-
-  let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, '').trim();
-  if (inner.startsWith('(') && inner.endsWith(')')) {
-    inner = inner.slice(1, -1).trim();
-  }
-
-  if (NOW_FUNCTION_PATTERN.test(inner)) return 'now()';
-  if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return 'clock_timestamp()';
-
-  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();
-  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';
-
-  return undefined;
-}
-
-export function parseRawDefault(
-  rawDefault: string,
-  nativeType?: string,
-): ColumnDefault | undefined {
-  const trimmed = rawDefault.trim();
-  const normalizedType = nativeType?.toLowerCase();
-
-  if (NEXTVAL_PATTERN.test(trimmed)) {
-    return { kind: 'function', expression: 'autoincrement()' };
-  }
-
-  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-  if (canonicalTimestamp) {
-    return { kind: 'function', expression: canonicalTimestamp };
-  }
-
-  if (UUID_PATTERN.test(trimmed) || UUID_OSSP_PATTERN.test(trimmed)) {
-    return { kind: 'function', expression: 'gen_random_uuid()' };
-  }
-
-  if (NULL_PATTERN.test(trimmed)) {
-    return { kind: 'literal', value: null };
-  }
-
-  if (TRUE_PATTERN.test(trimmed)) {
-    return { kind: 'literal', value: true };
-  }
-
-  if (FALSE_PATTERN.test(trimmed)) {
-    return { kind: 'literal', value: false };
-  }
-
-  if (NUMERIC_PATTERN.test(trimmed)) {
-    return { kind: 'literal', value: Number(trimmed) };
-  }
-
-  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-  if (stringMatch?.[1] !== undefined) {
-    const unescaped = stringMatch[1].replace(/''/g, "'");
-    if (normalizedType === 'json' || normalizedType === 'jsonb') {
-      if (JSON_CAST_SUFFIX.test(trimmed)) {
-        return { kind: 'function', expression: trimmed };
-      }
-      try {
-        return { kind: 'literal', value: JSON.parse(unescaped) };
-      } catch {
-        // Fall through to the string form for malformed/non-JSON values.
-      }
-    }
-    return { kind: 'literal', value: unescaped };
-  }
-
-  // Unrecognized — return as function with raw expression
-  return { kind: 'function', expression: trimmed };
-}

package/src/relation-inference.ts

@@ -1,239 +0,0 @@
-import type { SqlForeignKeyIR } from '@prisma-next/sql-schema-ir/types';
-import { deriveBackRelationFieldName, deriveRelationFieldName, pluralize } from './name-transforms';
-import type { PslPrintableSqlTable } from './schema-validation';
-import type { RelationField } from './types';
-
-/**
- * Default referential actions — when the FK uses these, we omit them from the PSL output.
- */
-const DEFAULT_ON_DELETE = 'noAction';
-const DEFAULT_ON_UPDATE = 'noAction';
-
-/**
- * Maps SqlReferentialAction to PSL-compatible casing.
- */
-const REFERENTIAL_ACTION_PSL: Record<string, string> = {
-  noAction: 'NoAction',
-  restrict: 'Restrict',
-  cascade: 'Cascade',
-  setNull: 'SetNull',
-  setDefault: 'SetDefault',
-};
-
-export type InferredRelations = {
-  /** Relation fields keyed by table name → array of fields to add */
-  readonly relationsByTable: ReadonlyMap<string, readonly RelationField[]>;
-};
-
-/**
- * Infers relation fields from foreign keys across all tables.
- *
- * For each FK:
- * 1. Creates a relation field on the child table (the table with the FK)
- * 2. Creates a back-relation field on the parent table (the referenced table)
- * 3. Detects 1:1 vs 1:N cardinality
- * 4. Handles multiple FKs to the same parent (named relations)
- * 5. Handles self-referencing FKs
- */
-export function inferRelations(
-  tables: Record<string, PslPrintableSqlTable>,
-  modelNameMap: ReadonlyMap<string, string>,
-): InferredRelations {
-  const relationsByTable = new Map<string, RelationField[]>();
-
-  // Track FK count from each child table to each parent table, for disambiguation
-  const fkCountByPair = new Map<string, number>();
-  for (const table of Object.values(tables)) {
-    for (const fk of table.foreignKeys) {
-      const pairKey = `${table.name}→${fk.referencedTable}`;
-      fkCountByPair.set(pairKey, (fkCountByPair.get(pairKey) ?? 0) + 1);
-    }
-  }
-
-  // Track which field names are used per table (including existing columns) for collision avoidance
-  const usedFieldNames = new Map<string, Set<string>>();
-  for (const table of Object.values(tables)) {
-    const names = new Set<string>();
-    for (const col of Object.values(table.columns)) {
-      names.add(col.name);
-    }
-    usedFieldNames.set(table.name, names);
-  }
-
-  for (const table of Object.values(tables)) {
-    for (const fk of table.foreignKeys) {
-      const childTableName = table.name;
-      const parentTableName = fk.referencedTable;
-      const childUsed = usedFieldNames.get(childTableName) as Set<string>;
-      const childModelName = modelNameMap.get(childTableName) ?? childTableName;
-      const parentModelName = modelNameMap.get(parentTableName) ?? parentTableName;
-      const pairKey = `${childTableName}→${parentTableName}`;
-      const isSelfRelation = childTableName === parentTableName;
-      const needsRelationName = (fkCountByPair.get(pairKey) as number) > 1 || isSelfRelation;
-
-      // Determine cardinality
-      const isOneToOne = detectOneToOne(fk, table);
-
-      // Child table: relation field (e.g., author User @relation(...))
-      const childRelFieldName = resolveUniqueFieldName(
-        deriveRelationFieldName(fk.columns, parentTableName),
-        childUsed,
-        parentModelName,
-      );
-      const relationName = needsRelationName
-        ? deriveRelationName(fk, childRelFieldName, parentModelName, isSelfRelation)
-        : undefined;
-      const childOptional = fk.columns.some(
-        (columnName) => table.columns[columnName]?.nullable ?? false,
-      );
-
-      const childRelField = buildChildRelationField(
-        childRelFieldName,
-        parentModelName,
-        fk,
-        childOptional,
-        relationName,
-      );
-
-      addRelationField(relationsByTable, childTableName, childRelField);
-      childUsed.add(childRelFieldName);
-
-      // Parent table: back-relation field (e.g., posts Post[])
-      const parentUsed = usedFieldNames.get(parentTableName) ?? new Set();
-      usedFieldNames.set(parentTableName, parentUsed);
-
-      const backRelFieldName = resolveUniqueFieldName(
-        deriveBackRelationFieldName(childModelName, isOneToOne),
-        parentUsed,
-        childModelName,
-      );
-
-      const backRelField: RelationField = {
-        fieldName: backRelFieldName,
-        typeName: childModelName,
-        optional: isOneToOne,
-        list: !isOneToOne,
-        relationName,
-      };
-
-      addRelationField(relationsByTable, parentTableName, backRelField);
-      parentUsed.add(backRelFieldName);
-    }
-  }
-
-  return { relationsByTable };
-}
-
-/**
- * Detects whether a FK represents a 1:1 relationship.
- * A FK is 1:1 if:
- * - The FK columns exactly match the table's PK columns, OR
- * - The FK columns exactly match a unique constraint
- */
-function detectOneToOne(fk: SqlForeignKeyIR, table: PslPrintableSqlTable): boolean {
-  const fkCols = [...fk.columns].sort();
-
-  // FK columns == PK columns → 1:1
-  if (table.primaryKey) {
-    const pkCols = [...table.primaryKey.columns].sort();
-    if (pkCols.length === fkCols.length && pkCols.every((c, i) => c === fkCols[i])) {
-      return true;
-    }
-  }
-
-  // FK columns == unique columns → 1:1
-  for (const unique of table.uniques) {
-    const uniqueCols = [...unique.columns].sort();
-    if (uniqueCols.length === fkCols.length && uniqueCols.every((c, i) => c === fkCols[i])) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Derives a relation name for disambiguation.
- * Uses the FK constraint name if available, otherwise generates one from the relation shape.
- */
-function deriveRelationName(
-  fk: SqlForeignKeyIR,
-  childRelationFieldName: string,
-  parentModelName: string,
-  isSelfRelation: boolean,
-): string {
-  if (fk.name) {
-    return fk.name;
-  }
-  if (isSelfRelation) {
-    return `${childRelationFieldName.charAt(0).toUpperCase() + childRelationFieldName.slice(1)}${pluralize(parentModelName)}`;
-  }
-  return fk.columns.join('_');
-}
-
-/**
- * Builds a child-side relation field with @relation attributes.
- */
-function buildChildRelationField(
-  fieldName: string,
-  parentModelName: string,
-  fk: SqlForeignKeyIR,
-  optional: boolean,
-  relationName?: string,
-): RelationField {
-  const onDelete = fk.onDelete && fk.onDelete !== DEFAULT_ON_DELETE ? fk.onDelete : undefined;
-  const onUpdate = fk.onUpdate && fk.onUpdate !== DEFAULT_ON_UPDATE ? fk.onUpdate : undefined;
-
-  return {
-    fieldName,
-    typeName: parentModelName,
-    referencedTableName: fk.referencedTable,
-    optional,
-    list: false,
-    relationName,
-    fkName: fk.name,
-    fields: fk.columns,
-    references: fk.referencedColumns,
-    onDelete: onDelete ? REFERENTIAL_ACTION_PSL[onDelete] : undefined,
-    onUpdate: onUpdate ? REFERENTIAL_ACTION_PSL[onUpdate] : undefined,
-  };
-}
-
-/**
- * Resolves a unique field name by appending the model name if there's a collision.
- */
-function resolveUniqueFieldName(
-  desired: string,
-  usedNames: ReadonlySet<string>,
-  fallbackSuffix: string,
-): string {
-  if (!usedNames.has(desired)) {
-    return desired;
-  }
-
-  // Try appending the model name
-  const withSuffix = `${desired}${fallbackSuffix}`;
-  if (!usedNames.has(withSuffix)) {
-    return withSuffix;
-  }
-
-  // Last resort: append a number
-  let counter = 2;
-  while (usedNames.has(`${desired}${counter}`)) {
-    counter++;
-  }
-  return `${desired}${counter}`;
-}
-
-function addRelationField(
-  map: Map<string, RelationField[]>,
-  tableName: string,
-  field: RelationField,
-): void {
-  const existing = map.get(tableName);
-  if (existing) {
-    existing.push(field);
-  } else {
-    map.set(tableName, [field]);
-  }
-}

package/src/schema-validation.ts

@@ -1,308 +0,0 @@
-import type { ColumnDefault } from '@prisma-next/contract/types';
-import type {
-  DependencyIR,
-  PrimaryKey,
-  SqlAnnotations,
-  SqlForeignKeyIR,
-  SqlIndexIR,
-  SqlReferentialAction,
-  SqlSchemaIR,
-  SqlUniqueIR,
-} from '@prisma-next/sql-schema-ir/types';
-
-const REFERENTIAL_ACTIONS = new Set<SqlReferentialAction>([
-  'noAction',
-  'restrict',
-  'cascade',
-  'setNull',
-  'setDefault',
-]);
-
-export type PrintableSqlColumnDefault = string | ColumnDefault;
-
-type ColumnDefaultLiteralValue = Extract<ColumnDefault, { readonly kind: 'literal' }>['value'];
-
-export type PslPrintableSqlColumn = {
-  readonly name: string;
-  readonly nativeType: string;
-  readonly nullable: boolean;
-  readonly default?: PrintableSqlColumnDefault;
-  readonly annotations?: SqlAnnotations;
-};
-
-export type PslPrintableSqlTable = {
-  readonly name: string;
-  readonly columns: Record<string, PslPrintableSqlColumn>;
-  readonly primaryKey?: PrimaryKey;
-  readonly foreignKeys: readonly SqlForeignKeyIR[];
-  readonly uniques: readonly SqlUniqueIR[];
-  readonly indexes: readonly SqlIndexIR[];
-  readonly annotations?: SqlAnnotations;
-};
-
-export type PslPrintableSqlSchemaIR = Omit<SqlSchemaIR, 'tables'> & {
-  readonly tables: Record<string, PslPrintableSqlTable>;
-};
-
-export function validatePrintableSqlSchemaIR(value: unknown): PslPrintableSqlSchemaIR {
-  const root = expectRecord(value, 'schema');
-
-  return {
-    tables: validateTables(root['tables'], 'schema.tables'),
-    dependencies: validateDependencies(root['dependencies'], 'schema.dependencies'),
-    ...ifDefined('annotations', validateAnnotations(root['annotations'], 'schema.annotations')),
-  };
-}
-
-function validateTables(value: unknown, path: string): Record<string, PslPrintableSqlTable> {
-  const tables = expectRecord(value, path);
-  const validated: Record<string, PslPrintableSqlTable> = {};
-
-  for (const [tableName, tableValue] of Object.entries(tables)) {
-    const tablePath = `${path}.${tableName}`;
-    const table = expectRecord(tableValue, tablePath);
-
-    validated[tableName] = {
-      name: expectString(table['name'], `${tablePath}.name`),
-      columns: validateColumns(table['columns'], `${tablePath}.columns`),
-      foreignKeys: validateForeignKeys(table['foreignKeys'], `${tablePath}.foreignKeys`),
-      uniques: validateUniques(table['uniques'], `${tablePath}.uniques`),
-      indexes: validateIndexes(table['indexes'], `${tablePath}.indexes`),
-      ...ifDefined(
-        'primaryKey',
-        validatePrimaryKey(table['primaryKey'], `${tablePath}.primaryKey`),
-      ),
-      ...ifDefined(
-        'annotations',
-        validateAnnotations(table['annotations'], `${tablePath}.annotations`),
-      ),
-    };
-  }
-
-  return validated;
-}
-
-function validateColumns(value: unknown, path: string): Record<string, PslPrintableSqlColumn> {
-  const columns = expectRecord(value, path);
-  const validated: Record<string, PslPrintableSqlColumn> = {};
-
-  for (const [columnName, columnValue] of Object.entries(columns)) {
-    const columnPath = `${path}.${columnName}`;
-    const column = expectRecord(columnValue, columnPath);
-
-    validated[columnName] = {
-      name: expectString(column['name'], `${columnPath}.name`),
-      nativeType: expectString(column['nativeType'], `${columnPath}.nativeType`),
-      nullable: expectBoolean(column['nullable'], `${columnPath}.nullable`),
-      ...ifDefined('default', validateColumnDefault(column['default'], `${columnPath}.default`)),
-      ...ifDefined(
-        'annotations',
-        validateAnnotations(column['annotations'], `${columnPath}.annotations`),
-      ),
-    };
-  }
-
-  return validated;
-}
-
-function validatePrimaryKey(value: unknown, path: string): PrimaryKey | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  const primaryKey = expectRecord(value, path);
-  return {
-    columns: validateStringArray(primaryKey['columns'], `${path}.columns`),
-    ...ifDefined('name', validateOptionalString(primaryKey['name'], `${path}.name`)),
-  };
-}
-
-function validateForeignKeys(value: unknown, path: string): readonly SqlForeignKeyIR[] {
-  const foreignKeys = expectArray(value, path);
-  return foreignKeys.map((foreignKey, index) => {
-    const foreignKeyPath = `${path}[${index}]`;
-    const record = expectRecord(foreignKey, foreignKeyPath);
-
-    return {
-      columns: validateStringArray(record['columns'], `${foreignKeyPath}.columns`),
-      referencedTable: expectString(record['referencedTable'], `${foreignKeyPath}.referencedTable`),
-      referencedColumns: validateStringArray(
-        record['referencedColumns'],
-        `${foreignKeyPath}.referencedColumns`,
-      ),
-      ...ifDefined('name', validateOptionalString(record['name'], `${foreignKeyPath}.name`)),
-      ...ifDefined(
-        'onDelete',
-        validateReferentialAction(record['onDelete'], `${foreignKeyPath}.onDelete`),
-      ),
-      ...ifDefined(
-        'onUpdate',
-        validateReferentialAction(record['onUpdate'], `${foreignKeyPath}.onUpdate`),
-      ),
-      ...ifDefined(
-        'annotations',
-        validateAnnotations(record['annotations'], `${foreignKeyPath}.annotations`),
-      ),
-    };
-  });
-}
-
-function validateUniques(value: unknown, path: string): readonly SqlUniqueIR[] {
-  const uniques = expectArray(value, path);
-  return uniques.map((uniqueValue, index) => {
-    const uniquePath = `${path}[${index}]`;
-    const unique = expectRecord(uniqueValue, uniquePath);
-
-    return {
-      columns: validateStringArray(unique['columns'], `${uniquePath}.columns`),
-      ...ifDefined('name', validateOptionalString(unique['name'], `${uniquePath}.name`)),
-      ...ifDefined(
-        'annotations',
-        validateAnnotations(unique['annotations'], `${uniquePath}.annotations`),
-      ),
-    };
-  });
-}
-
-function validateIndexes(value: unknown, path: string): readonly SqlIndexIR[] {
-  const indexes = expectArray(value, path);
-  return indexes.map((indexValue, index) => {
-    const indexPath = `${path}[${index}]`;
-    const record = expectRecord(indexValue, indexPath);
-
-    return {
-      columns: validateStringArray(record['columns'], `${indexPath}.columns`),
-      unique: expectBoolean(record['unique'], `${indexPath}.unique`),
-      ...ifDefined('name', validateOptionalString(record['name'], `${indexPath}.name`)),
-      ...ifDefined(
-        'annotations',
-        validateAnnotations(record['annotations'], `${indexPath}.annotations`),
-      ),
-    };
-  });
-}
-
-function validateDependencies(value: unknown, path: string): readonly DependencyIR[] {
-  const dependencies = expectArray(value, path);
-  return dependencies.map((dependencyValue, index) => {
-    const dependencyPath = `${path}[${index}]`;
-    const dependency = expectRecord(dependencyValue, dependencyPath);
-
-    return {
-      id: expectString(dependency['id'], `${dependencyPath}.id`),
-    };
-  });
-}
-
-function validateAnnotations(value: unknown, path: string): SqlAnnotations | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  return expectRecord(value, path);
-}
-
-function validateColumnDefault(
-  value: unknown,
-  path: string,
-): PrintableSqlColumnDefault | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  if (typeof value === 'string') {
-    return value;
-  }
-
-  const columnDefault = expectRecord(value, path);
-  const kind = expectString(columnDefault['kind'], `${path}.kind`);
-
-  if (kind === 'literal') {
-    if (!Object.hasOwn(columnDefault, 'value')) {
-      throw new Error(`${path}.value must be present for literal defaults`);
-    }
-    return {
-      kind: 'literal',
-      value: columnDefault['value'] as ColumnDefaultLiteralValue,
-    };
-  }
-
-  if (kind === 'function') {
-    return {
-      kind: 'function',
-      expression: expectString(columnDefault['expression'], `${path}.expression`),
-    };
-  }
-
-  throw new Error(`${path}.kind must be "literal" or "function"`);
-}
-
-function validateReferentialAction(value: unknown, path: string): SqlReferentialAction | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  const action = expectString(value, path) as SqlReferentialAction;
-  if (!REFERENTIAL_ACTIONS.has(action)) {
-    throw new Error(
-      `${path} must be one of ${[...REFERENTIAL_ACTIONS].map((item) => `"${item}"`).join(', ')}`,
-    );
-  }
-  return action;
-}
-
-function validateStringArray(value: unknown, path: string): readonly string[] {
-  const items = expectArray(value, path);
-  return items.map((item, index) => expectString(item, `${path}[${index}]`));
-}
-
-function validateOptionalString(value: unknown, path: string): string | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  return expectString(value, path);
-}
-
-function expectRecord(value: unknown, path: string): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw new Error(`${path} must be an object`);
-  }
-
-  return value as Record<string, unknown>;
-}
-
-function expectArray(value: unknown, path: string): readonly unknown[] {
-  if (!Array.isArray(value)) {
-    throw new Error(`${path} must be an array`);
-  }
-
-  return value;
-}
-
-function expectString(value: unknown, path: string): string {
-  if (typeof value !== 'string') {
-    throw new Error(`${path} must be a string`);
-  }
-
-  return value;
-}
-
-function expectBoolean(value: unknown, path: string): boolean {
-  if (typeof value !== 'boolean') {
-    throw new Error(`${path} must be a boolean`);
-  }
-
-  return value;
-}
-
-function ifDefined<TKey extends string, TValue>(
-  key: TKey,
-  value: TValue | undefined,
-): { readonly [K in TKey]: TValue } | Record<string, never> {
-  if (value === undefined) {
-    return {};
-  }
-
-  return { [key]: value } as { readonly [K in TKey]: TValue };
-}