@vibeorm/generator 1.3.0 → 2.0.0-alpha.1

package/src/generators/generate-delegates.ts

@@ -1,590 +0,0 @@
-import type { Model, Schema, ScalarField } from "@vibeorm/parser";
-import { fileHeader, toCamelCase } from "../utils.ts";
-
-const NUMERIC_PRISMA_TYPES = new Set(["Int", "Float", "Decimal", "BigInt"]);
-
-/**
- * Generates delegate interfaces for each model.
- * These are the user-facing APIs: db.user.findMany(), db.post.create(), etc.
- *
- * Each method uses a generic parameter to capture the exact literal type
- * of the args object, enabling TypeScript to narrow the return type
- * through the GetFindResult conditional type.
- */
-export function generateDelegates(params: { schema: Schema }): string {
-  const { schema } = params;
-  const parts: string[] = [fileHeader()];
-
-  // Imports
-  const argsImports = schema.models
-    .flatMap((m) => [
-      `${m.name}FindManyArgs`,
-      `${m.name}FindFirstArgs`,
-      `${m.name}FindUniqueArgs`,
-      `${m.name}CreateArgs`,
-      `${m.name}CreateManyArgs`,
-      `${m.name}CreateManyAndReturnArgs`,
-      `${m.name}UpdateArgs`,
-      `${m.name}UpsertArgs`,
-      `${m.name}DeleteArgs`,
-      `${m.name}DeleteManyArgs`,
-      `${m.name}UpdateManyArgs`,
-      `${m.name}CountArgs`,
-      `${m.name}AggregateArgs`,
-      `${m.name}GroupByArgs`,
-    ])
-    .join(", ");
-  parts.push(`import type { ${argsImports} } from "./args.ts";`);
-
-  const payloadImports = schema.models
-    .map((m) => `$${m.name}Payload`)
-    .join(", ");
-
-  // Include JsonValue if any model has Json scalar fields (used in aggregate/groupBy types)
-  const hasJsonField = schema.models.some((m) =>
-    m.fields.some((f) => f.kind === "scalar" && f.prismaType === "Json")
-  );
-  const extraImports = hasJsonField ? ", JsonValue" : "";
-  parts.push(`import type { ${payloadImports}${extraImports} } from "./models.ts";`);
-
-  parts.push(`import type { GetResult, Exact } from "./result.ts";`);
-
-  // Import enums if any models have enum fields
-  if (schema.enums.length > 0) {
-    const enumImports = schema.enums.map((e) => e.name).join(", ");
-    parts.push(`import type { ${enumImports} } from "./enums.ts";`);
-  }
-  parts.push("");
-
-  // Generate delegate for each model
-  for (const model of schema.models) {
-    parts.push(generateModelDelegate({ model }));
-    parts.push(generateAggregateResultType({ model }));
-    parts.push(generateGroupByResultType({ model }));
-  }
-
-  return parts.join("\n");
-}
-
-function generateModelDelegate(params: { model: Model }): string {
-  const { model } = params;
-  const p = `$${model.name}Payload`;
-  const modelVar = toCamelCase({ str: model.name });
-
-  const findManyWhereBlock = buildFindManyWhereBlock({ model });
-  const uniqueWhereBlock = buildUniqueWhereBlock({ model });
-  const createDataBlock = buildObjectBlock({
-    key: "data",
-    lines: getExampleDataLines({ model }),
-  });
-  const updateDataBlock = buildObjectBlock({
-    key: "data",
-    lines: getExampleUpdateLines({ model }),
-  });
-  const createManyDataBlock = buildArrayOfObjectsBlock({
-    key: "data",
-    lines: getExampleDataLines({ model }),
-  });
-  const upsertCreateBlock = buildObjectBlock({
-    key: "create",
-    lines: getExampleDataLines({ model }),
-  });
-  const upsertUpdateBlock = buildObjectBlock({
-    key: "update",
-    lines: getExampleUpdateLines({ model }),
-  });
-  const includeBlock = buildIncludeBlock({ model });
-  const orderByField = getOrderByFieldName({ model });
-
-  return `/**
- * Delegate API for the ${model.name} model.
- * Access this via \`db.${modelVar}\`.
- */
-export type ${model.name}Delegate = {
-  /**
-   * Find zero or more ${model.name} records.
-   *
-   * @example
-   * const rows = await db.${modelVar}.findMany();
-   *
-   * @example
-   * const filteredRows = await db.${modelVar}.findMany({
-${findManyWhereBlock}
-   * });
-   *
-   * @example
-   * const page = await db.${modelVar}.findMany({
-${findManyWhereBlock}${includeBlock}
-   *   orderBy: {
-   *     ${orderByField}: "desc",
-   *   },
-   *   take: 20,
-   *   skip: 0,
-   * });
-   */
-  findMany<T extends ${model.name}FindManyArgs>(
-    args?: Exact<T, ${model.name}FindManyArgs>,
-  ): Promise<GetResult<${p}, T, "findMany">>;
-
-  /**
-   * Find the first ${model.name} record matching a filter.
-   *
-   * @example
-   * const row = await db.${modelVar}.findFirst({
-${findManyWhereBlock}
-   *   orderBy: {
-   *     ${orderByField}: "desc",
-   *   },
-   * });
-   */
-  findFirst<T extends ${model.name}FindFirstArgs>(
-    args?: Exact<T, ${model.name}FindFirstArgs>,
-  ): Promise<GetResult<${p}, T, "findFirst">>;
-
-  /**
-   * Find one ${model.name} record by a unique field.
-   *
-   * @example
-   * const row = await db.${modelVar}.findUnique({
-${uniqueWhereBlock}
-   * });
-   */
-  findUnique<T extends ${model.name}FindUniqueArgs>(
-    args: Exact<T, ${model.name}FindUniqueArgs>,
-  ): Promise<GetResult<${p}, T, "findUnique">>;
-
-  /**
-   * Find one ${model.name} record by a unique field, or throw if not found.
-   *
-   * @example
-   * const row = await db.${modelVar}.findUniqueOrThrow({
-${uniqueWhereBlock}
-   * });
-   */
-  findUniqueOrThrow<T extends ${model.name}FindUniqueArgs>(
-    args: Exact<T, ${model.name}FindUniqueArgs>,
-  ): Promise<GetResult<${p}, T, "findUniqueOrThrow">>;
-
-  /**
-   * Find the first ${model.name} record matching a filter, or throw if not found.
-   */
-  findFirstOrThrow<T extends ${model.name}FindFirstArgs>(
-    args?: Exact<T, ${model.name}FindFirstArgs>,
-  ): Promise<GetResult<${p}, T, "findFirstOrThrow">>;
-
-  /**
-   * Create one ${model.name} record.
-   *
-   * @example
-   * const row = await db.${modelVar}.create({
-${createDataBlock}
-   * });
-   */
-  create<T extends ${model.name}CreateArgs>(
-    args: Exact<T, ${model.name}CreateArgs>,
-  ): Promise<GetResult<${p}, T, "create">>;
-
-  /**
-   * Create multiple ${model.name} records in one query.
-   *
-   * @example
-   * const result = await db.${modelVar}.createMany({
-${createManyDataBlock}
-   *   skipDuplicates: true,
-   * });
-   */
-  createMany(
-    args: ${model.name}CreateManyArgs,
-  ): Promise<{ count: number }>;
-
-  /**
-   * Create multiple ${model.name} records and return selected fields.
-   *
-   * @example
-   * const rows = await db.${modelVar}.createManyAndReturn({
-${createManyDataBlock}
-   *   select: {
-   *     // Choose fields to return
-   *   },
-   * });
-   */
-  createManyAndReturn<T extends ${model.name}CreateManyAndReturnArgs>(
-    args: Exact<T, ${model.name}CreateManyAndReturnArgs>,
-  ): Promise<GetResult<${p}, T, "createManyAndReturn">>;
-
-  /**
-   * Update one ${model.name} record.
-   *
-   * @example
-   * const row = await db.${modelVar}.update({
-${uniqueWhereBlock}
-${updateDataBlock}
-   * });
-   */
-  update<T extends ${model.name}UpdateArgs>(
-    args: Exact<T, ${model.name}UpdateArgs>,
-  ): Promise<GetResult<${p}, T, "update">>;
-
-  /**
-   * Update one ${model.name} record if it exists, or create it otherwise.
-   *
-   * @example
-   * const row = await db.${modelVar}.upsert({
-${uniqueWhereBlock}
-${upsertCreateBlock}
-${upsertUpdateBlock}
-   * });
-   */
-  upsert<T extends ${model.name}UpsertArgs>(
-    args: Exact<T, ${model.name}UpsertArgs>,
-  ): Promise<GetResult<${p}, T, "upsert">>;
-
-  /**
-   * Delete one ${model.name} record by a unique field.
-   *
-   * @example
-   * const row = await db.${modelVar}.delete({
-${uniqueWhereBlock}
-   * });
-   */
-  delete<T extends ${model.name}DeleteArgs>(
-    args: Exact<T, ${model.name}DeleteArgs>,
-  ): Promise<GetResult<${p}, T, "delete">>;
-
-  /**
-   * Delete multiple ${model.name} records.
-   *
-   * @example
-   * const result = await db.${modelVar}.deleteMany({
-${findManyWhereBlock}
-   * });
-   */
-  deleteMany(
-    args?: ${model.name}DeleteManyArgs,
-  ): Promise<{ count: number }>;
-
-  /**
-   * Update multiple ${model.name} records.
-   *
-   * @example
-   * const result = await db.${modelVar}.updateMany({
-${findManyWhereBlock}
-${updateDataBlock}
-   * });
-   */
-  updateMany(
-    args: ${model.name}UpdateManyArgs,
-  ): Promise<{ count: number }>;
-
-  /**
-   * Count ${model.name} records.
-   *
-   * @example
-   * const total = await db.${modelVar}.count({
-${findManyWhereBlock}
-   * });
-   */
-  count(
-    args?: ${model.name}CountArgs,
-  ): Promise<number>;
-
-  /**
-   * Run aggregate calculations on ${model.name} records.
-   *
-   * @example
-   * const stats = await db.${modelVar}.aggregate({
-${findManyWhereBlock}
-   *   _count: true,
-   *   _avg: {
-   *     // Choose numeric fields
-   *   },
-   * });
-   */
-  aggregate(
-    args: ${model.name}AggregateArgs,
-  ): Promise<Aggregate${model.name}Result>;
-
-  /**
-   * Group ${model.name} records by scalar fields.
-   *
-   * @example
-   * const grouped = await db.${modelVar}.groupBy({
-   *   by: ["${orderByField}"],
-${findManyWhereBlock}
-   *   _count: true,
-   * });
-   */
-  groupBy(
-    args: ${model.name}GroupByArgs,
-  ): Promise<${model.name}GroupByResult[]>;
-};
-`;
-}
-
-function buildObjectBlock(params: { key: string; lines: string[] }): string {
-  const { key, lines } = params;
-  const safeLines = lines.length > 0 ? lines : ["// Add model fields here"];
-  return `   *   ${key}: {
-${safeLines.map((line) => `   *     ${line}`).join("\n")}
-   *   },`;
-}
-
-function buildArrayOfObjectsBlock(params: { key: string; lines: string[] }): string {
-  const { key, lines } = params;
-  const safeLines = lines.length > 0 ? lines : ["// Add model fields here"];
-  return `   *   ${key}: [
-   *     {
-${safeLines.map((line) => `   *       ${line}`).join("\n")}
-   *     },
-   *   ],`;
-}
-
-function buildFindManyWhereBlock(params: { model: Model }): string {
-  return buildObjectBlock({
-    key: "where",
-    lines: getFindManyWhereLines({ model: params.model }),
-  });
-}
-
-function buildUniqueWhereBlock(params: { model: Model }): string {
-  return buildObjectBlock({
-    key: "where",
-    lines: getUniqueWhereLines({ model: params.model }),
-  });
-}
-
-function buildIncludeBlock(params: { model: Model }): string {
-  const relationField = params.model.fields.find((f) => f.kind === "relation");
-  if (!relationField) return "";
-  return `
-   *   include: {
-   *     ${relationField.name}: true,
-   *   },`;
-}
-
-function getFindManyWhereLines(params: { model: Model }): string[] {
-  const field = getPreferredWhereField({ model: params.model });
-  if (!field) {
-    return ["// Add model-specific filters here"];
-  }
-
-  const fieldNameLower = field.name.toLowerCase();
-  if (field.prismaType === "String") {
-    if (fieldNameLower.includes("email")) {
-      return [`${field.name}: { endsWith: "@example.com" },`];
-    }
-    return [`${field.name}: { contains: "sample" },`];
-  }
-
-  if (field.prismaType === "DateTime") {
-    return [`${field.name}: { gte: new Date("2024-01-01T00:00:00.000Z") },`];
-  }
-
-  if (field.prismaType === "Boolean") {
-    return [`${field.name}: true,`];
-  }
-
-  if (field.prismaType === "BigInt") {
-    return [`${field.name}: { gte: 1n },`];
-  }
-
-  if (field.prismaType === "Decimal") {
-    return [`${field.name}: { gte: "1.00" },`];
-  }
-
-  if (field.prismaType === "Int" || field.prismaType === "Float") {
-    return [`${field.name}: { gte: 1 },`];
-  }
-
-  if (field.prismaType === "Json") {
-    return [`${field.name}: { equals: { key: "value" } },`];
-  }
-
-  if (field.prismaType === "Bytes") {
-    return [`${field.name}: { equals: new Uint8Array([1, 2, 3]) },`];
-  }
-
-  return [`${field.name}: { equals: ${getSampleValueForScalarField({ field })} },`];
-}
-
-function getUniqueWhereLines(params: { model: Model }): string[] {
-  const uniqueField = params.model.fields.find(
-    (f): f is ScalarField =>
-      f.kind === "scalar" && !f.isList && (f.isId || f.isUnique)
-  );
-
-  if (!uniqueField) {
-    return ["// Provide a unique field (for example id or email)"];
-  }
-
-  return [`${uniqueField.name}: ${getSampleValueForScalarField({ field: uniqueField })},`];
-}
-
-function getExampleDataLines(params: { model: Model }): string[] {
-  const candidates = params.model.fields.filter(
-    (f): f is ScalarField =>
-      f.kind === "scalar" &&
-      !f.isList &&
-      !f.isId &&
-      !f.isUpdatedAt &&
-      !f.default
-  );
-
-  const selected = candidates.length > 0
-    ? candidates
-    : params.model.fields.filter(
-      (f): f is ScalarField =>
-        f.kind === "scalar" && !f.isList && !f.isId && !f.isUpdatedAt
-    );
-
-  if (selected.length === 0) {
-    return ["// Add model fields here"];
-  }
-
-  return selected.slice(0, 2).map((field) => {
-    return `${field.name}: ${getSampleValueForScalarField({ field })},`;
-  });
-}
-
-function getExampleUpdateLines(params: { model: Model }): string[] {
-  const selected = params.model.fields.filter(
-    (f): f is ScalarField =>
-      f.kind === "scalar" && !f.isList && !f.isId && !f.isUpdatedAt
-  );
-
-  if (selected.length === 0) {
-    return ["// Add fields to update"];
-  }
-
-  return selected.slice(0, 2).map((field) => {
-    return `${field.name}: ${getSampleValueForScalarField({ field })},`;
-  });
-}
-
-function getPreferredWhereField(params: { model: Model }): ScalarField | undefined {
-  const fields = params.model.fields.filter(
-    (f): f is ScalarField => f.kind === "scalar" && !f.isList
-  );
-
-  return fields.find((f) => !f.isId && f.prismaType === "String")
-    ?? fields.find((f) => !f.isId && f.prismaType === "DateTime")
-    ?? fields.find((f) => !f.isId && NUMERIC_PRISMA_TYPES.has(f.prismaType))
-    ?? fields.find((f) => !f.isId && f.prismaType === "Boolean")
-    ?? fields.find((f) => !f.isId)
-    ?? fields[0];
-}
-
-function getOrderByFieldName(params: { model: Model }): string {
-  const scalarFields = params.model.fields.filter(
-    (f): f is ScalarField => f.kind === "scalar" && !f.isList
-  );
-
-  const preferred = scalarFields.find((f) => f.name === "createdAt")
-    ?? scalarFields.find((f) => f.name === "updatedAt")
-    ?? scalarFields.find((f) => f.isId)
-    ?? scalarFields[0];
-
-  return preferred?.name ?? "id";
-}
-
-function getSampleValueForScalarField(params: { field: ScalarField }): string {
-  const { field } = params;
-  const fieldNameLower = field.name.toLowerCase();
-
-  if (field.prismaType === "String") {
-    if (fieldNameLower.includes("email")) return '"user@example.com"';
-    if (fieldNameLower.includes("name")) return '"Example"';
-    if (fieldNameLower.includes("title")) return '"Example title"';
-    return '"sample"';
-  }
-
-  if (field.prismaType === "Boolean") return "true";
-  if (field.prismaType === "Int" || field.prismaType === "Float") return "1";
-  if (field.prismaType === "Decimal") return '"1.00"';
-  if (field.prismaType === "BigInt") return "1n";
-  if (field.prismaType === "DateTime") return 'new Date("2024-01-01T00:00:00.000Z")';
-  if (field.prismaType === "Json") return '{ key: "value" }';
-  if (field.prismaType === "Bytes") return "new Uint8Array([1, 2, 3])";
-
-  return "undefined";
-}
-
-function generateAggregateResultType(params: { model: Model }): string {
-  const { model } = params;
-
-  const scalarFields = model.fields.filter(
-    (f): f is ScalarField => f.kind === "scalar"
-  );
-  const numericFields = scalarFields.filter(
-    (f) => NUMERIC_PRISMA_TYPES.has(f.prismaType)
-  );
-
-  const countFields = [
-    `    _all: number;`,
-    ...scalarFields.map((f) => `    ${f.name}: number;`),
-  ];
-
-  const avgFields = numericFields.map((f) => `    ${f.name}: number | null;`);
-  const sumFields = numericFields.map((f) => `    ${f.name}: number | null;`);
-  const minFields = scalarFields.map((f) => {
-    const tsType = f.tsType;
-    return `    ${f.name}: ${tsType} | null;`;
-  });
-  const maxFields = scalarFields.map((f) => {
-    const tsType = f.tsType;
-    return `    ${f.name}: ${tsType} | null;`;
-  });
-
-  return `export type Aggregate${model.name}Result = {
-  _count: number | {
-${countFields.join("\n")}
-  };
-  _avg: {
-${avgFields.length > 0 ? avgFields.join("\n") : "    [key: string]: never;"}
-  } | null;
-  _sum: {
-${sumFields.length > 0 ? sumFields.join("\n") : "    [key: string]: never;"}
-  } | null;
-  _min: {
-${minFields.join("\n")}
-  } | null;
-  _max: {
-${maxFields.join("\n")}
-  } | null;
-};
-`;
-}
-
-function generateGroupByResultType(params: { model: Model }): string {
-  const { model } = params;
-
-  const scalarFields = model.fields.filter(
-    (f): f is ScalarField => f.kind === "scalar"
-  );
-
-  // GroupBy result is a partial of scalars + aggregate fields
-  const scalarEntries = scalarFields.map((f) => {
-    const tsType = f.tsType;
-    const nullable = f.isRequired ? "" : " | null";
-    return `  ${f.name}?: ${tsType}${nullable};`;
-  });
-
-  // Also include enum fields
-  const enumEntries = model.fields
-    .filter((f) => f.kind === "enum")
-    .map((f) => {
-      if (f.kind !== "enum") return "";
-      const nullable = f.isRequired ? "" : " | null";
-      return `  ${f.name}?: ${f.enumName}${nullable};`;
-    });
-
-  return `export type ${model.name}GroupByResult = {
-${[...scalarEntries, ...enumEntries].join("\n")}
-  _count?: number | Record<string, number>;
-  _avg?: Record<string, number | null>;
-  _sum?: Record<string, number | null>;
-  _min?: Record<string, unknown>;
-  _max?: Record<string, unknown>;
-};
-`;
-}

package/src/generators/generate-enums.ts

@@ -1,28 +0,0 @@
-import type { Enum } from "@vibeorm/parser";
-import { fileHeader } from "../utils.ts";
-
-export function generateEnums(params: { enums: Enum[] }): string {
-  const { enums } = params;
-
-  if (enums.length === 0) {
-    return fileHeader() + "\nexport {};\n";
-  }
-
-  const parts: string[] = [fileHeader()];
-
-  for (const enumDef of enums) {
-    // Generate a const object (not a TS enum — objects are more flexible)
-    const values = enumDef.values
-      .map((v) => `  ${v.name}: "${v.name}" as const`)
-      .join(",\n");
-
-    parts.push(`export const ${enumDef.name} = {
-${values},
-} as const;
-
-export type ${enumDef.name} = (typeof ${enumDef.name})[keyof typeof ${enumDef.name}];
-`);
-  }
-
-  return parts.join("\n");
-}