@vibeorm/generator 1.0.0

package/src/generators/generate-inputs.ts

@@ -0,0 +1,626 @@
+import type {
+  Model,
+  Schema,
+  ScalarField,
+  EnumField,
+  RelationField,
+  PrismaScalarType,
+} from "@vibeorm/parser";
+import { fileHeader } from "../utils.ts";
+
+/**
+ * Generates WhereInput, OrderByInput, CreateInput, UpdateInput types for each model.
+ */
+export function generateInputs(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // Import enums
+  if (schema.enums.length > 0) {
+    const enumImports = schema.enums.map((e) => e.name).join(", ");
+    parts.push(`import type { ${enumImports} } from "./enums.ts";`);
+  }
+
+  // Import model types for relation filter references
+  parts.push(`import type { JsonValue } from "./models.ts";\n`);
+
+  // Sort direction
+  parts.push(`export type SortOrder = "asc" | "desc";
+
+export type SortOrderWithNulls = {
+  sort: SortOrder;
+  nulls?: "first" | "last";
+};
+`);
+
+  // Generate for each model
+  for (const model of schema.models) {
+    parts.push(generateWhereInput({ model, schema }));
+    parts.push(generateWhereUniqueInput({ model }));
+    parts.push(generateOrderByInput({ model }));
+    parts.push(generateCreateInput({ model, schema }));
+    parts.push(generateUpdateInput({ model, schema }));
+  }
+
+  return parts.join("\n");
+}
+
+// ─── Where Input ──────────────────────────────────────────────────
+
+function generateWhereInput(params: { model: Model; schema: Schema }): string {
+  const { model } = params;
+
+  const entries: string[] = [];
+
+  // Logical combinators
+  entries.push(`  AND?: ${model.name}WhereInput | ${model.name}WhereInput[];`);
+  entries.push(`  OR?: ${model.name}WhereInput[];`);
+  entries.push(`  NOT?: ${model.name}WhereInput | ${model.name}WhereInput[];`);
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar") {
+      if (field.isList) {
+        // Array field — use list filter type
+        const listFilterType = scalarListFilterType({ field });
+        entries.push(`  ${field.name}?: ${listFilterType};`);
+      } else {
+        entries.push(`  ${field.name}?: ${scalarFilterType({ field })} | ${scalarTsType({ field })};`);
+      }
+    } else if (field.kind === "enum") {
+      entries.push(`  ${field.name}?: EnumFilter<${field.enumName}> | ${field.enumName};`);
+    } else if (field.kind === "relation") {
+      if (field.isList) {
+        entries.push(`  ${field.name}?: ${field.relatedModel}ListRelationFilter;`);
+      } else {
+        entries.push(`  ${field.name}?: ${field.relatedModel}WhereInput | ${field.isRequired ? "" : "null | "}${field.relatedModel}RelationFilter;`);
+      }
+    }
+  }
+
+  return `export type ${model.name}WhereInput = {
+${entries.join("\n")}
+};
+`;
+}
+
+function generateWhereUniqueInput(params: { model: Model }): string {
+  const { model } = params;
+
+  // Collect unique-able fields: @id, @unique, @@id, @@unique
+  const uniqueFields: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar" || field.kind === "enum") {
+      if (field.isId || field.isUnique) {
+        uniqueFields.push(field.name);
+      }
+    }
+  }
+
+  if (uniqueFields.length === 0) {
+    // Fallback: use all primary key fields
+    for (const pkField of model.primaryKey.fields) {
+      uniqueFields.push(pkField);
+    }
+  }
+
+  const entries = uniqueFields.map((fieldName) => {
+    const field = model.fields.find((f) => f.name === fieldName);
+    if (!field || field.kind === "relation") return "";
+    const tsType = field.kind === "scalar" ? field.tsType : field.enumName;
+    return `  ${fieldName}?: ${tsType};`;
+  });
+
+  // Also support composite unique if @@id is composite
+  if (model.primaryKey.isComposite) {
+    const compositeType = model.primaryKey.fields
+      .map((fn) => {
+        const field = model.fields.find((f) => f.name === fn);
+        if (!field || field.kind === "relation") return `${fn}: unknown`;
+        const tsType = field.kind === "scalar" ? field.tsType : field.enumName;
+        return `${fn}: ${tsType}`;
+      })
+      .join("; ");
+    entries.push(`  ${model.primaryKey.fields.join("_")}?: { ${compositeType} };`);
+  }
+
+  return `export type ${model.name}WhereUniqueInput = {
+${entries.join("\n")}
+};
+`;
+}
+
+// ─── OrderBy Input ────────────────────────────────────────────────
+
+function generateOrderByInput(params: { model: Model }): string {
+  const { model } = params;
+
+  const entries: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar" || field.kind === "enum") {
+      entries.push(`  ${field.name}?: SortOrder | SortOrderWithNulls;`);
+    } else if (field.kind === "relation") {
+      if (field.isList) {
+        // Order by relation count: { posts: { _count: "desc" } }
+        entries.push(`  ${field.name}?: { _count?: SortOrder };`);
+      } else {
+        // Order by relation field: { author: { name: "asc" } }
+        entries.push(`  ${field.name}?: ${field.relatedModel}OrderByInput;`);
+      }
+    }
+  }
+
+  return `export type ${model.name}OrderByInput = {
+${entries.join("\n")}
+};
+`;
+}
+
+// ─── Create Input ─────────────────────────────────────────────────
+
+function generateCreateInput(params: {
+  model: Model;
+  schema: Schema;
+}): string {
+  const { model } = params;
+
+  const entries: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar") {
+      // Skip auto-generated fields (autoincrement, now, uuid, cuid, @updatedAt)
+      const isAutoGenerated = field.default &&
+        (field.default.kind === "autoincrement" ||
+          field.default.kind === "now" ||
+          field.default.kind === "uuid" ||
+          field.default.kind === "cuid" ||
+          field.default.kind === "nanoid" ||
+          field.default.kind === "ulid");
+      const isOptional = !field.isRequired || field.default !== undefined || isAutoGenerated || field.isUpdatedAt;
+      const tsType = scalarTsType({ field });
+      entries.push(`  ${field.name}${isOptional ? "?" : ""}: ${tsType};`);
+    } else if (field.kind === "enum") {
+      const isOptional = !field.isRequired || field.default !== undefined;
+      entries.push(`  ${field.name}${isOptional ? "?" : ""}: ${field.enumName};`);
+    } else if (field.kind === "relation") {
+      // Relation fields in create — nested create/connect
+      if (field.isList) {
+        entries.push(`  ${field.name}?: {
+    create?: ${field.relatedModel}CreateInput | ${field.relatedModel}CreateInput[];
+    connect?: ${field.relatedModel}WhereUniqueInput | ${field.relatedModel}WhereUniqueInput[];
+    connectOrCreate?: { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput } | { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput }[];
+  };`);
+      } else {
+        entries.push(`  ${field.name}?: {
+    create?: ${field.relatedModel}CreateInput;
+    connect?: ${field.relatedModel}WhereUniqueInput;
+    connectOrCreate?: { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput };
+  };`);
+      }
+    }
+  }
+
+  return `export type ${model.name}CreateInput = {
+${entries.join("\n")}
+};
+`;
+}
+
+// ─── Update Input ─────────────────────────────────────────────────
+
+function generateUpdateInput(params: {
+  model: Model;
+  schema: Schema;
+}): string {
+  const { model } = params;
+
+  const entries: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar") {
+      if (field.isList) {
+        // Array field — use list update operations
+        const listUpdateType = scalarListUpdateType({ field });
+        entries.push(`  ${field.name}?: ${listUpdateType};`);
+      } else {
+        const tsType = scalarTsType({ field });
+        const atomicType = numericFieldUpdateType({ field });
+        if (atomicType) {
+          entries.push(`  ${field.name}?: ${tsType} | ${atomicType};`);
+        } else {
+          entries.push(`  ${field.name}?: ${tsType};`);
+        }
+      }
+    } else if (field.kind === "enum") {
+      entries.push(`  ${field.name}?: ${field.enumName};`);
+    } else if (field.kind === "relation") {
+      if (field.isList) {
+        entries.push(`  ${field.name}?: {
+    create?: ${field.relatedModel}CreateInput | ${field.relatedModel}CreateInput[];
+    connect?: ${field.relatedModel}WhereUniqueInput | ${field.relatedModel}WhereUniqueInput[];
+    connectOrCreate?: { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput } | { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput }[];
+    disconnect?: ${field.relatedModel}WhereUniqueInput | ${field.relatedModel}WhereUniqueInput[];
+    delete?: ${field.relatedModel}WhereUniqueInput | ${field.relatedModel}WhereUniqueInput[];
+    set?: ${field.relatedModel}WhereUniqueInput[];
+    update?: { where: ${field.relatedModel}WhereUniqueInput; data: ${field.relatedModel}UpdateInput } | { where: ${field.relatedModel}WhereUniqueInput; data: ${field.relatedModel}UpdateInput }[];
+    upsert?: { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput; update: ${field.relatedModel}UpdateInput } | { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput; update: ${field.relatedModel}UpdateInput }[];
+    updateMany?: { where: ${field.relatedModel}WhereInput; data: ${field.relatedModel}UpdateInput } | { where: ${field.relatedModel}WhereInput; data: ${field.relatedModel}UpdateInput }[];
+    deleteMany?: ${field.relatedModel}WhereInput | ${field.relatedModel}WhereInput[];
+  };`);
+      } else {
+        entries.push(`  ${field.name}?: {
+    create?: ${field.relatedModel}CreateInput;
+    connect?: ${field.relatedModel}WhereUniqueInput;
+    connectOrCreate?: { where: ${field.relatedModel}WhereUniqueInput; create: ${field.relatedModel}CreateInput };
+    disconnect?: boolean;
+    delete?: boolean;
+    update?: ${field.relatedModel}UpdateInput;
+    upsert?: { create: ${field.relatedModel}CreateInput; update: ${field.relatedModel}UpdateInput };
+  };`);
+      }
+    }
+  }
+
+  return `export type ${model.name}UpdateInput = {
+${entries.join("\n")}
+};
+`;
+}
+
+// ─── Scalar Filter Types ──────────────────────────────────────────
+
+function scalarTsType(params: { field: ScalarField }): string {
+  const { field } = params;
+  const base = field.tsType;
+  if (field.isList) return `${base}[]`;
+  if (!field.isRequired) return `${base} | null`;
+  return base;
+}
+
+function scalarFilterType(params: { field: ScalarField }): string {
+  const { field } = params;
+  const nullable = !field.isRequired && !field.isList;
+
+  switch (field.prismaType) {
+    case "String":
+      return nullable ? "NullableStringFilter" : "StringFilter";
+    case "Int":
+    case "Float":
+    case "Decimal":
+      return nullable ? "NullableNumberFilter" : "NumberFilter";
+    case "BigInt":
+      return nullable ? "NullableBigIntFilter" : "BigIntFilter";
+    case "Boolean":
+      return nullable ? "NullableBooleanFilter" : "BooleanFilter";
+    case "DateTime":
+      return nullable ? "NullableDateTimeFilter" : "DateTimeFilter";
+    case "Json":
+      return "JsonFilter";
+    case "Bytes":
+      return nullable ? "NullableBytesFilter" : "BytesFilter";
+    default:
+      return nullable ? "NullableStringFilter" : "StringFilter";
+  }
+}
+
+function numericFieldUpdateType(params: { field: ScalarField }): string | null {
+  switch (params.field.prismaType) {
+    case "Int":
+      return "IntFieldUpdateOperationsInput";
+    case "Float":
+    case "Decimal":
+      return "FloatFieldUpdateOperationsInput";
+    case "BigInt":
+      return "BigIntFieldUpdateOperationsInput";
+    default:
+      return null;
+  }
+}
+
+function scalarListFilterType(params: { field: ScalarField }): string {
+  switch (params.field.prismaType) {
+    case "String":
+      return "StringListFilter";
+    case "Int":
+    case "Float":
+    case "Decimal":
+      return "NumberListFilter";
+    case "BigInt":
+      return "BigIntListFilter";
+    case "Boolean":
+      return "BooleanListFilter";
+    case "DateTime":
+      return "DateTimeListFilter";
+    default:
+      return "StringListFilter";
+  }
+}
+
+function scalarListUpdateType(params: { field: ScalarField }): string {
+  switch (params.field.prismaType) {
+    case "String":
+      return "StringListUpdateInput";
+    case "Int":
+    case "Float":
+    case "Decimal":
+      return "NumberListUpdateInput";
+    case "BigInt":
+      return "BigIntListUpdateInput";
+    case "Boolean":
+      return "BooleanListUpdateInput";
+    case "DateTime":
+      return "DateTimeListUpdateInput";
+    default:
+      return "StringListUpdateInput";
+  }
+}
+
+// The filter types will be generated as shared types at the bottom of the file
+export function generateFilterTypes(): string {
+  return `
+// ─── Shared Filter Types ──────────────────────────────────────────
+
+export type StringFilter = {
+  equals?: string;
+  not?: string | StringFilter;
+  in?: string[];
+  notIn?: string[];
+  lt?: string;
+  lte?: string;
+  gt?: string;
+  gte?: string;
+  contains?: string;
+  startsWith?: string;
+  endsWith?: string;
+  mode?: "default" | "insensitive";
+};
+
+export type NumberFilter = {
+  equals?: number;
+  not?: number | NumberFilter;
+  in?: number[];
+  notIn?: number[];
+  lt?: number;
+  lte?: number;
+  gt?: number;
+  gte?: number;
+};
+
+export type BigIntFilter = {
+  equals?: bigint;
+  not?: bigint | BigIntFilter;
+  in?: bigint[];
+  notIn?: bigint[];
+  lt?: bigint;
+  lte?: bigint;
+  gt?: bigint;
+  gte?: bigint;
+};
+
+export type BooleanFilter = {
+  equals?: boolean;
+  not?: boolean | BooleanFilter;
+};
+
+export type DateTimeFilter = {
+  equals?: Date | string;
+  not?: Date | string | DateTimeFilter;
+  in?: (Date | string)[];
+  notIn?: (Date | string)[];
+  lt?: Date | string;
+  lte?: Date | string;
+  gt?: Date | string;
+  gte?: Date | string;
+};
+
+export type JsonFilter = {
+  equals?: JsonValue;
+  not?: JsonValue;
+  path?: string[];
+  string_contains?: string;
+  string_starts_with?: string;
+  string_ends_with?: string;
+  array_contains?: JsonValue;
+  array_starts_with?: JsonValue;
+  array_ends_with?: JsonValue;
+};
+
+export type BytesFilter = {
+  equals?: Buffer;
+  not?: Buffer | BytesFilter;
+};
+
+export type EnumFilter<T extends string> = {
+  equals?: T;
+  not?: T | EnumFilter<T>;
+  in?: T[];
+  notIn?: T[];
+};
+
+// ─── Nullable Filter Types ───────────────────────────────────────
+// These allow null in equals/not for nullable fields (e.g. { not: null })
+
+export type NullableStringFilter = {
+  equals?: string | null;
+  not?: string | null | NullableStringFilter;
+  in?: string[];
+  notIn?: string[];
+  lt?: string;
+  lte?: string;
+  gt?: string;
+  gte?: string;
+  contains?: string;
+  startsWith?: string;
+  endsWith?: string;
+  mode?: "default" | "insensitive";
+};
+
+export type NullableNumberFilter = {
+  equals?: number | null;
+  not?: number | null | NullableNumberFilter;
+  in?: number[];
+  notIn?: number[];
+  lt?: number;
+  lte?: number;
+  gt?: number;
+  gte?: number;
+};
+
+export type NullableBigIntFilter = {
+  equals?: bigint | null;
+  not?: bigint | null | NullableBigIntFilter;
+  in?: bigint[];
+  notIn?: bigint[];
+  lt?: bigint;
+  lte?: bigint;
+  gt?: bigint;
+  gte?: bigint;
+};
+
+export type NullableBooleanFilter = {
+  equals?: boolean | null;
+  not?: boolean | null | NullableBooleanFilter;
+};
+
+export type NullableDateTimeFilter = {
+  equals?: Date | string | null;
+  not?: Date | string | null | NullableDateTimeFilter;
+  in?: (Date | string)[];
+  notIn?: (Date | string)[];
+  lt?: Date | string;
+  lte?: Date | string;
+  gt?: Date | string;
+  gte?: Date | string;
+};
+
+export type NullableBytesFilter = {
+  equals?: Buffer | null;
+  not?: Buffer | null | NullableBytesFilter;
+};
+
+// ─── Atomic Number Operations ────────────────────────────────────
+// Used in UpdateInput for numeric fields: { viewCount: { increment: 1 } }
+
+export type IntFieldUpdateOperationsInput = {
+  set?: number;
+  increment?: number;
+  decrement?: number;
+  multiply?: number;
+  divide?: number;
+};
+
+export type FloatFieldUpdateOperationsInput = {
+  set?: number;
+  increment?: number;
+  decrement?: number;
+  multiply?: number;
+  divide?: number;
+};
+
+export type BigIntFieldUpdateOperationsInput = {
+  set?: bigint;
+  increment?: bigint;
+  decrement?: bigint;
+  multiply?: bigint;
+  divide?: bigint;
+};
+
+// ─── Scalar List Filter Types ────────────────────────────────────
+// Used for String[], Int[], etc. array fields
+
+export type StringListFilter = {
+  has?: string;
+  hasEvery?: string[];
+  hasSome?: string[];
+  isEmpty?: boolean;
+  equals?: string[];
+};
+
+export type NumberListFilter = {
+  has?: number;
+  hasEvery?: number[];
+  hasSome?: number[];
+  isEmpty?: boolean;
+  equals?: number[];
+};
+
+export type BigIntListFilter = {
+  has?: bigint;
+  hasEvery?: bigint[];
+  hasSome?: bigint[];
+  isEmpty?: boolean;
+  equals?: bigint[];
+};
+
+export type BooleanListFilter = {
+  has?: boolean;
+  hasEvery?: boolean[];
+  hasSome?: boolean[];
+  isEmpty?: boolean;
+  equals?: boolean[];
+};
+
+export type DateTimeListFilter = {
+  has?: Date | string;
+  hasEvery?: (Date | string)[];
+  hasSome?: (Date | string)[];
+  isEmpty?: boolean;
+  equals?: (Date | string)[];
+};
+
+// ─── Scalar List Update Operations ───────────────────────────────
+
+export type StringListUpdateInput = {
+  set?: string[];
+  push?: string | string[];
+};
+
+export type NumberListUpdateInput = {
+  set?: number[];
+  push?: number | number[];
+};
+
+export type BigIntListUpdateInput = {
+  set?: bigint[];
+  push?: bigint | bigint[];
+};
+
+export type BooleanListUpdateInput = {
+  set?: boolean[];
+  push?: boolean | boolean[];
+};
+
+export type DateTimeListUpdateInput = {
+  set?: (Date | string)[];
+  push?: Date | string | (Date | string)[];
+};
+`;
+}
+
+// Relation filter helper types
+export function generateRelationFilterTypes(params: {
+  schema: Schema;
+}): string {
+  const { schema } = params;
+  const parts: string[] = [];
+
+  for (const model of schema.models) {
+    // List relation filter (for oneToMany/manyToMany)
+    parts.push(`export type ${model.name}ListRelationFilter = {
+  every?: ${model.name}WhereInput;
+  some?: ${model.name}WhereInput;
+  none?: ${model.name}WhereInput;
+};
+`);
+
+    // Single relation filter (for oneToOne/manyToOne)
+    parts.push(`export type ${model.name}RelationFilter = {
+  is?: ${model.name}WhereInput | null;
+  isNot?: ${model.name}WhereInput | null;
+};
+`);
+  }
+
+  return parts.join("\n");
+}