@prisma-next/sql-contract-ts 0.3.0-pr.99.6 → 0.4.0-dev.1

package/src/contract-warnings.ts

@@ -0,0 +1,242 @@
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import {
+  type ContractModelBuilder,
+  type ModelAttributesSpec,
+  normalizeRelationFieldNames,
+  type RelationBuilder,
+  type RelationState,
+  type ScalarFieldBuilder,
+  type SqlStageSpec,
+} from './contract-dsl';
+
+type RuntimeModel = ContractModelBuilder<
+  string | undefined,
+  Record<string, ScalarFieldBuilder>,
+  Record<string, RelationBuilder<RelationState>>,
+  ModelAttributesSpec | undefined,
+  SqlStageSpec | undefined
+>;
+
+type RuntimeModelSpec = {
+  readonly modelName: string;
+  readonly tableName: string;
+  readonly relations: Record<string, RelationBuilder<RelationState>>;
+  readonly sqlSpec: SqlStageSpec | undefined;
+};
+
+type RuntimeCollection = {
+  readonly storageTypes: Record<string, StorageTypeInstance>;
+  readonly models: Record<string, RuntimeModel>;
+  readonly modelSpecs: ReadonlyMap<string, RuntimeModelSpec>;
+};
+
+function hasNamedModelToken(models: Record<string, RuntimeModel>, modelName: string): boolean {
+  return models[modelName]?.stageOne.modelName === modelName;
+}
+
+function formatFieldSelection(fieldNames: readonly string[]): string {
+  if (fieldNames.length === 1) {
+    return `'${fieldNames[0]}'`;
+  }
+
+  return `[${fieldNames.map((fieldName) => `'${fieldName}'`).join(', ')}]`;
+}
+
+function formatTokenFieldSelection(modelName: string, fieldNames: readonly string[]): string {
+  if (fieldNames.length === 1) {
+    return `${modelName}.refs.${fieldNames[0]}`;
+  }
+
+  return `[${fieldNames.map((fieldName) => `${modelName}.refs.${fieldName}`).join(', ')}]`;
+}
+
+function formatConstraintsRefCall(modelName: string, fieldNames: readonly string[]): string {
+  if (fieldNames.length === 1) {
+    return `constraints.ref('${modelName}', '${fieldNames[0]}')`;
+  }
+
+  return `[${fieldNames
+    .map((fieldName) => `constraints.ref('${modelName}', '${fieldName}')`)
+    .join(', ')}]`;
+}
+
+function formatRelationModelDisplay(
+  relationModel:
+    | RelationState['toModel']
+    | Extract<RelationState, { kind: 'manyToMany' }>['through'],
+): string {
+  if (relationModel.kind === 'lazyRelationModelName') {
+    return `() => ${relationModel.resolve()}`;
+  }
+
+  return relationModel.source === 'string'
+    ? `'${relationModel.modelName}'`
+    : relationModel.modelName;
+}
+
+function formatRelationCall(relation: RelationState, targetModelDisplay: string): string {
+  if (relation.kind === 'belongsTo') {
+    const from = formatFieldSelection(normalizeRelationFieldNames(relation.from));
+    const to = formatFieldSelection(normalizeRelationFieldNames(relation.to));
+    return `rel.belongsTo(${targetModelDisplay}, { from: ${from}, to: ${to} })`;
+  }
+
+  if (relation.kind === 'hasMany' || relation.kind === 'hasOne') {
+    const by = formatFieldSelection(normalizeRelationFieldNames(relation.by));
+    return `rel.${relation.kind}(${targetModelDisplay}, { by: ${by} })`;
+  }
+
+  const throughDisplay = formatRelationModelDisplay(relation.through);
+  const from = formatFieldSelection(normalizeRelationFieldNames(relation.from));
+  const to = formatFieldSelection(normalizeRelationFieldNames(relation.to));
+  return `rel.manyToMany(${targetModelDisplay}, { through: ${throughDisplay}, from: ${from}, to: ${to} })`;
+}
+
+function formatManyToManyCallWithThrough(
+  relation: Extract<RelationState, { kind: 'manyToMany' }>,
+  throughDisplay: string,
+): string {
+  const targetDisplay = formatRelationModelDisplay(relation.toModel);
+  const from = formatFieldSelection(normalizeRelationFieldNames(relation.from));
+  const to = formatFieldSelection(normalizeRelationFieldNames(relation.to));
+  return `rel.manyToMany(${targetDisplay}, { through: ${throughDisplay}, from: ${from}, to: ${to} })`;
+}
+
+const WARNING_BATCH_THRESHOLD = 5;
+
+function flushWarnings(warnings: readonly string[]): void {
+  if (warnings.length === 0) {
+    return;
+  }
+
+  if (warnings.length <= WARNING_BATCH_THRESHOLD) {
+    for (const message of warnings) {
+      process.emitWarning(message, { code: 'PN_CONTRACT_TYPED_FALLBACK_AVAILABLE' });
+    }
+    return;
+  }
+
+  process.emitWarning(
+    `${warnings.length} contract references use string fallbacks where typed alternatives are available. ` +
+      'Use named model tokens and typed storage type refs for autocomplete and type safety.\n' +
+      warnings.map((w) => `  - ${w}`).join('\n'),
+    { code: 'PN_CONTRACT_TYPED_FALLBACK_AVAILABLE' },
+  );
+}
+
+function formatFallbackWarning(location: string, current: string, suggested: string): string {
+  return (
+    `Contract ${location} uses ${current}. ` +
+    `Use ${suggested} when the named model token is available in the same contract to keep typed relation targets and model refs.`
+  );
+}
+
+export function emitTypedNamedTypeFallbackWarnings(
+  models: Record<string, RuntimeModel>,
+  storageTypes: Record<string, StorageTypeInstance>,
+): void {
+  const warnings: string[] = [];
+  const warnedFields = new Set<string>();
+
+  for (const [modelName, modelDefinition] of Object.entries(models)) {
+    for (const [fieldName, fieldBuilder] of Object.entries(modelDefinition.stageOne.fields)) {
+      const fieldState = fieldBuilder.build();
+      if (typeof fieldState.typeRef !== 'string' || !(fieldState.typeRef in storageTypes)) {
+        continue;
+      }
+
+      const warningKey = `${modelName}.${fieldName}`;
+      if (warnedFields.has(warningKey)) {
+        continue;
+      }
+      warnedFields.add(warningKey);
+
+      warnings.push(
+        `Contract field "${modelName}.${fieldName}" uses field.namedType('${fieldState.typeRef}'). ` +
+          `Use field.namedType(types.${fieldState.typeRef}) when the storage type is declared in the same contract to keep autocomplete and typed local refs.`,
+      );
+    }
+  }
+
+  flushWarnings(warnings);
+}
+
+export function emitTypedCrossModelFallbackWarnings(collection: RuntimeCollection): void {
+  const warnings: string[] = [];
+  const warnedKeys = new Set<string>();
+
+  for (const spec of collection.modelSpecs.values()) {
+    for (const [relationName, relationBuilder] of Object.entries(spec.relations)) {
+      const relation = relationBuilder.build();
+
+      if (
+        relation.toModel.kind === 'relationModelName' &&
+        relation.toModel.source === 'string' &&
+        hasNamedModelToken(collection.models, relation.toModel.modelName)
+      ) {
+        const warningKey = `${spec.modelName}.${relationName}.toModel`;
+        if (!warnedKeys.has(warningKey)) {
+          warnedKeys.add(warningKey);
+
+          const current = formatRelationCall(relation, `'${relation.toModel.modelName}'`);
+          const suggested = formatRelationCall(relation, relation.toModel.modelName);
+          warnings.push(
+            formatFallbackWarning(
+              `relation "${spec.modelName}.${relationName}"`,
+              current,
+              suggested,
+            ),
+          );
+        }
+      }
+
+      if (
+        relation.kind === 'manyToMany' &&
+        relation.through.kind === 'relationModelName' &&
+        relation.through.source === 'string' &&
+        hasNamedModelToken(collection.models, relation.through.modelName)
+      ) {
+        const warningKey = `${spec.modelName}.${relationName}.through`;
+        if (!warnedKeys.has(warningKey)) {
+          warnedKeys.add(warningKey);
+
+          const current = formatManyToManyCallWithThrough(
+            relation,
+            `'${relation.through.modelName}'`,
+          );
+          const suggested = formatManyToManyCallWithThrough(relation, relation.through.modelName);
+          warnings.push(
+            formatFallbackWarning(
+              `relation "${spec.modelName}.${relationName}"`,
+              current,
+              suggested,
+            ),
+          );
+        }
+      }
+    }
+
+    for (const [foreignKeyIndex, foreignKey] of (spec.sqlSpec?.foreignKeys ?? []).entries()) {
+      if (
+        foreignKey.targetSource !== 'string' ||
+        !hasNamedModelToken(collection.models, foreignKey.targetModel)
+      ) {
+        continue;
+      }
+
+      const warningKey = `${spec.modelName}.sql.foreignKeys.${foreignKeyIndex}`;
+      if (warnedKeys.has(warningKey)) {
+        continue;
+      }
+      warnedKeys.add(warningKey);
+
+      const current = formatConstraintsRefCall(foreignKey.targetModel, foreignKey.targetFields);
+      const suggested = formatTokenFieldSelection(foreignKey.targetModel, foreignKey.targetFields);
+      warnings.push(
+        formatFallbackWarning(`model "${spec.modelName}"`, `${current} in .sql(...)`, suggested),
+      );
+    }
+  }
+
+  flushWarnings(warnings);
+}

package/src/exports/config-types.ts

@@ -0,0 +1,2 @@
+export type { ContractConfig } from '@prisma-next/config/config-types';
+export { typescriptContract } from '../config-types';

package/src/exports/contract-builder.ts

@@ -1,2 +1,23 @@
-export type { ColumnBuilder } from '../contract-builder';
-export { defineContract } from '../contract-builder';
+export type {
+  ComposedAuthoringHelpers,
+  ContractInput,
+  ContractModelBuilder,
+  ScalarFieldBuilder,
+} from '../contract-builder';
+export {
+  buildSqlContractFromDefinition,
+  defineContract,
+  field,
+  model,
+  rel,
+} from '../contract-builder';
+export type {
+  ContractDefinition,
+  FieldNode,
+  ForeignKeyNode,
+  IndexNode,
+  ModelNode,
+  PrimaryKeyNode,
+  RelationNode,
+  UniqueConstraintNode,
+} from '../contract-definition';

package/dist/chunk-HTNUNGA2.js

@@ -1,346 +0,0 @@
-// src/contract.ts
-import { type } from "arktype";
-var StorageColumnSchema = type.declare().type({
-  nativeType: "string",
-  codecId: "string",
-  nullable: "boolean",
-  "typeParams?": "Record<string, unknown>",
-  "typeRef?": "string"
-});
-var StorageTypeInstanceSchema = type.declare().type({
-  codecId: "string",
-  nativeType: "string",
-  typeParams: "Record<string, unknown>"
-});
-var PrimaryKeySchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  "name?": "string"
-});
-var UniqueConstraintSchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  "name?": "string"
-});
-var IndexSchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  "name?": "string"
-});
-var ForeignKeyReferencesSchema = type.declare().type({
-  table: "string",
-  columns: type.string.array().readonly()
-});
-var ForeignKeySchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  references: ForeignKeyReferencesSchema,
-  "name?": "string"
-});
-var StorageTableSchema = type.declare().type({
-  columns: type({ "[string]": StorageColumnSchema }),
-  "primaryKey?": PrimaryKeySchema,
-  uniques: UniqueConstraintSchema.array().readonly(),
-  indexes: IndexSchema.array().readonly(),
-  foreignKeys: ForeignKeySchema.array().readonly()
-});
-var StorageSchema = type.declare().type({
-  tables: type({ "[string]": StorageTableSchema }),
-  "types?": type({ "[string]": StorageTypeInstanceSchema })
-});
-var ModelFieldSchema = type.declare().type({
-  column: "string"
-});
-var ModelStorageSchema = type.declare().type({
-  table: "string"
-});
-var ModelSchema = type.declare().type({
-  storage: ModelStorageSchema,
-  fields: type({ "[string]": ModelFieldSchema }),
-  relations: type({ "[string]": "unknown" })
-});
-var SqlContractSchema = type({
-  "schemaVersion?": "'1'",
-  target: "string",
-  targetFamily: "'sql'",
-  coreHash: "string",
-  "profileHash?": "string",
-  "capabilities?": "Record<string, Record<string, boolean>>",
-  "extensionPacks?": "Record<string, unknown>",
-  "meta?": "Record<string, unknown>",
-  "sources?": "Record<string, unknown>",
-  models: type({ "[string]": ModelSchema }),
-  storage: StorageSchema
-});
-function validateContractStructure(value) {
-  const rawValue = value;
-  if (rawValue.targetFamily !== void 0 && rawValue.targetFamily !== "sql") {
-    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);
-  }
-  const contractResult = SqlContractSchema(value);
-  if (contractResult instanceof type.errors) {
-    const messages = contractResult.map((p) => p.message).join("; ");
-    throw new Error(`Contract structural validation failed: ${messages}`);
-  }
-  return contractResult;
-}
-function computeMappings(models, _storage, existingMappings) {
-  const modelToTable = {};
-  const tableToModel = {};
-  const fieldToColumn = {};
-  const columnToField = {};
-  for (const [modelName, model] of Object.entries(models)) {
-    const tableName = model.storage.table;
-    modelToTable[modelName] = tableName;
-    tableToModel[tableName] = modelName;
-    const modelFieldToColumn = {};
-    for (const [fieldName, field] of Object.entries(model.fields)) {
-      const columnName = field.column;
-      modelFieldToColumn[fieldName] = columnName;
-      if (!columnToField[tableName]) {
-        columnToField[tableName] = {};
-      }
-      columnToField[tableName][columnName] = fieldName;
-    }
-    fieldToColumn[modelName] = modelFieldToColumn;
-  }
-  return {
-    modelToTable: existingMappings?.modelToTable ?? modelToTable,
-    tableToModel: existingMappings?.tableToModel ?? tableToModel,
-    fieldToColumn: existingMappings?.fieldToColumn ?? fieldToColumn,
-    columnToField: existingMappings?.columnToField ?? columnToField,
-    codecTypes: existingMappings?.codecTypes ?? {},
-    operationTypes: existingMappings?.operationTypes ?? {}
-  };
-}
-function validateContractLogic(structurallyValidatedContract) {
-  const { storage, models } = structurallyValidatedContract;
-  const tableNames = new Set(Object.keys(storage.tables));
-  const typeInstanceNames = new Set(Object.keys(storage.types ?? {}));
-  if (storage.types) {
-    for (const [typeName, typeInstance] of Object.entries(storage.types)) {
-      if (Array.isArray(typeInstance.typeParams)) {
-        throw new Error(
-          `Type instance "${typeName}" has invalid typeParams: must be a plain object, not an array`
-        );
-      }
-    }
-  }
-  for (const [tableName, table] of Object.entries(storage.tables)) {
-    for (const [columnName, column] of Object.entries(table.columns)) {
-      if (column.typeParams !== void 0 && column.typeRef !== void 0) {
-        throw new Error(
-          `Column "${columnName}" in table "${tableName}" has both typeParams and typeRef; these are mutually exclusive`
-        );
-      }
-      if (column.typeParams !== void 0 && Array.isArray(column.typeParams)) {
-        throw new Error(
-          `Column "${columnName}" in table "${tableName}" has invalid typeParams: must be a plain object, not an array`
-        );
-      }
-      if (column.typeRef !== void 0 && !typeInstanceNames.has(column.typeRef)) {
-        throw new Error(
-          `Column "${columnName}" in table "${tableName}" references non-existent type instance "${column.typeRef}" (not found in storage.types)`
-        );
-      }
-    }
-  }
-  for (const [modelName, modelUnknown] of Object.entries(models)) {
-    const model = modelUnknown;
-    if (!model.storage?.table) {
-      throw new Error(`Model "${modelName}" is missing storage.table`);
-    }
-    const tableName = model.storage.table;
-    if (!tableNames.has(tableName)) {
-      throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
-    }
-    const table = storage.tables[tableName];
-    if (!table) {
-      throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
-    }
-    if (!table.primaryKey) {
-      throw new Error(`Model "${modelName}" table "${tableName}" is missing a primary key`);
-    }
-    const columnNames = new Set(Object.keys(table.columns));
-    if (!model.fields) {
-      throw new Error(`Model "${modelName}" is missing fields`);
-    }
-    for (const [fieldName, fieldUnknown] of Object.entries(model.fields)) {
-      const field = fieldUnknown;
-      if (!field.column) {
-        throw new Error(`Model "${modelName}" field "${fieldName}" is missing column property`);
-      }
-      if (!columnNames.has(field.column)) {
-        throw new Error(
-          `Model "${modelName}" field "${fieldName}" references non-existent column "${field.column}" in table "${tableName}"`
-        );
-      }
-    }
-    if (model.relations) {
-      for (const [relationName, relation] of Object.entries(model.relations)) {
-        if (typeof relation === "object" && relation !== null && "on" in relation && "to" in relation) {
-          const on = relation.on;
-          const cardinality = relation.cardinality;
-          if (on.parentCols && on.childCols) {
-            if (cardinality === "1:N") {
-              continue;
-            }
-            const hasMatchingFk = table.foreignKeys?.some((fk) => {
-              return fk.columns.length === on.childCols?.length && fk.columns.every((col, i) => col === on.childCols?.[i]) && fk.references.table && fk.references.columns.length === on.parentCols?.length && fk.references.columns.every((col, i) => col === on.parentCols?.[i]);
-            });
-            if (!hasMatchingFk) {
-              throw new Error(
-                `Model "${modelName}" relation "${relationName}" does not have a corresponding foreign key in table "${tableName}"`
-              );
-            }
-          }
-        }
-      }
-    }
-  }
-  for (const [tableName, table] of Object.entries(storage.tables)) {
-    const columnNames = new Set(Object.keys(table.columns));
-    if (table.primaryKey) {
-      for (const colName of table.primaryKey.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" primaryKey references non-existent column "${colName}"`
-          );
-        }
-      }
-    }
-    for (const unique of table.uniques) {
-      for (const colName of unique.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" unique constraint references non-existent column "${colName}"`
-          );
-        }
-      }
-    }
-    for (const index of table.indexes) {
-      for (const colName of index.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(`Table "${tableName}" index references non-existent column "${colName}"`);
-        }
-      }
-    }
-    for (const fk of table.foreignKeys) {
-      for (const colName of fk.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" foreignKey references non-existent column "${colName}"`
-          );
-        }
-      }
-      if (!tableNames.has(fk.references.table)) {
-        throw new Error(
-          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`
-        );
-      }
-      const referencedTable = storage.tables[fk.references.table];
-      if (!referencedTable) {
-        throw new Error(
-          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`
-        );
-      }
-      const referencedColumnNames = new Set(Object.keys(referencedTable.columns));
-      for (const colName of fk.references.columns) {
-        if (!referencedColumnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.references.table}"`
-          );
-        }
-      }
-      if (fk.columns.length !== fk.references.columns.length) {
-        throw new Error(
-          `Table "${tableName}" foreignKey column count (${fk.columns.length}) does not match referenced column count (${fk.references.columns.length})`
-        );
-      }
-    }
-  }
-}
-function normalizeContract(contract) {
-  const contractObj = contract;
-  let normalizedStorage = contractObj["storage"];
-  if (normalizedStorage && typeof normalizedStorage === "object" && normalizedStorage !== null) {
-    const storage = normalizedStorage;
-    const tables = storage["tables"];
-    if (tables) {
-      const normalizedTables = {};
-      for (const [tableName, table] of Object.entries(tables)) {
-        const tableObj = table;
-        const columns = tableObj["columns"];
-        if (columns) {
-          const normalizedColumns = {};
-          for (const [columnName, column] of Object.entries(columns)) {
-            const columnObj = column;
-            const normalizedColumn = {
-              ...columnObj,
-              nullable: columnObj["nullable"] ?? false
-            };
-            normalizedColumns[columnName] = normalizedColumn;
-          }
-          normalizedTables[tableName] = {
-            ...tableObj,
-            columns: normalizedColumns,
-            uniques: tableObj["uniques"] ?? [],
-            indexes: tableObj["indexes"] ?? [],
-            foreignKeys: tableObj["foreignKeys"] ?? []
-          };
-        } else {
-          normalizedTables[tableName] = tableObj;
-        }
-      }
-      normalizedStorage = {
-        ...storage,
-        tables: normalizedTables
-      };
-    }
-  }
-  let normalizedModels = contractObj["models"];
-  if (normalizedModels && typeof normalizedModels === "object" && normalizedModels !== null) {
-    const models = normalizedModels;
-    const normalizedModelsObj = {};
-    for (const [modelName, model] of Object.entries(models)) {
-      const modelObj = model;
-      normalizedModelsObj[modelName] = {
-        ...modelObj,
-        relations: modelObj["relations"] ?? {}
-      };
-    }
-    normalizedModels = normalizedModelsObj;
-  }
-  return {
-    ...contractObj,
-    models: normalizedModels,
-    relations: contractObj["relations"] ?? {},
-    storage: normalizedStorage,
-    extensionPacks: contractObj["extensionPacks"] ?? {},
-    capabilities: contractObj["capabilities"] ?? {},
-    meta: contractObj["meta"] ?? {},
-    sources: contractObj["sources"] ?? {}
-  };
-}
-function validateContract(value) {
-  const normalized = normalizeContract(value);
-  const structurallyValid = validateContractStructure(normalized);
-  const contractForValidation = structurallyValid;
-  validateContractLogic(contractForValidation);
-  const existingMappings = contractForValidation.mappings;
-  const mappings = computeMappings(
-    contractForValidation.models,
-    contractForValidation.storage,
-    existingMappings
-  );
-  const contractWithMappings = {
-    ...structurallyValid,
-    models: contractForValidation.models,
-    relations: contractForValidation.relations,
-    storage: contractForValidation.storage,
-    mappings
-  };
-  return contractWithMappings;
-}
-
-export {
-  computeMappings,
-  validateContract
-};
-//# sourceMappingURL=chunk-HTNUNGA2.js.map