@vibeorm/generator 1.3.1 → 2.0.0-alpha.10

package/src/generators/generate-client.ts

@@ -1,252 +0,0 @@
-import type { Model, Schema } from "@vibeorm/parser";
-import { fileHeader, toCamelCase } from "../utils.ts";
-
-/**
- * Generates the main index.ts file that:
- * - Re-exports all types
- * - Creates the VibeClient class that wires delegates to the runtime
- */
-export function generateClient(params: { schema: Schema }): string {
-  const { schema } = params;
-  const parts: string[] = [fileHeader()];
-
-  // Re-exports
-  parts.push(`export * from "./enums.ts";`);
-  parts.push(`export * from "./models.ts";`);
-  parts.push(`export * from "./inputs.ts";`);
-  parts.push(`export * from "./args.ts";`);
-  parts.push(`export * from "./result.ts";`);
-  parts.push(`export * from "./delegates.ts";`);
-  parts.push(`export * from "./schemas.ts";`);
-  parts.push(`export * from "./view-types.ts";`);
-  parts.push(``);
-
-  // Import delegate types
-  const delegateImports = schema.models
-    .map((m) => `${m.name}Delegate`)
-    .join(", ");
-  parts.push(`import type { ${delegateImports} } from "./delegates.ts";`);
-
-  // Import view types
-  parts.push(`import type { ViewDefinitionInput, ViewClient } from "./view-types.ts";`);
-
-  // Import runtime
-  parts.push(`import { createClient } from "@vibeorm/runtime";`);
-  parts.push(`import type { VibeClientOptions, TransactionOptions } from "@vibeorm/runtime";`);
-  parts.push(``);
-
-  // Import schemas for validation wiring
-  const schemaImports = schema.models.flatMap((m) => [
-    `${m.name}Schema`,
-    `${m.name}CreateInputSchema`,
-    `${m.name}UpdateInputSchema`,
-    `${m.name}WhereInputSchema`,
-  ]);
-  parts.push(`import { ${schemaImports.join(", ")} } from "./schemas.ts";`);
-  parts.push(``);
-
-  // Generate the model metadata object that the runtime needs
-  parts.push(generateModelMeta({ schema }));
-
-  // Generate the schemas map for validation wiring
-  parts.push(generateSchemasMap({ schema }));
-
-  // Generate the VibeClient type (intersection of all delegates)
-  const clientProperties = schema.models
-    .map((m) => generateClientProperty({ model: m }))
-    .join("\n");
-
-  parts.push(`export type VibeClientInstance = {
-${clientProperties}
-  $transaction<T>(fn: (tx: VibeClientInstance) => Promise<T>, options?: TransactionOptions): Promise<T>;
-  $transaction(promises: Promise<unknown>[], options?: TransactionOptions): Promise<unknown[]>;
-  $queryRaw<T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T[]>;
-  $executeRaw(strings: TemplateStringsArray, ...values: unknown[]): Promise<number>;
-  $queryRawUnsafe<T = unknown>(query: string, ...values: unknown[]): Promise<T[]>;
-  $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
-  $connect(): Promise<void>;
-  $disconnect(): Promise<void>;
-
-  /**
-   * Create a read-only view that restricts which fields are returned per model.
-   *
-   * @example
-   * const publicApi = db.defineView({
-   *   name: "public-api",
-   *   definition: {
-   *     user: { id: true, name: true, createdAt: true },
-   *     post: { id: true, title: true },
-   *   },
-   * });
-   *
-   * // Only returns { id, name, createdAt }
-   * const users = await publicApi.user.findMany();
-   *
-   * // Reveal extra fields (accessible but excluded from JSON.stringify)
-   * const user = await publicApi.user.findUniqueOrThrow({
-   *   where: { id: 1 },
-   *   reveal: { email: true },
-   * });
-   * user.email;           // accessible
-   * JSON.stringify(user);  // { id, name, createdAt } — email excluded
-   * user.$unsafe();        // { id, name, createdAt, email } — escape hatch
-   */
-  defineView<D extends ViewDefinitionInput>(params: {
-    name: string;
-    definition: D;
-  }): ViewClient<D>;
-};
-`);
-
-  // Generate the VibeClient constructor function
-  parts.push(`export function VibeClient(options: VibeClientOptions): VibeClientInstance {
-  return createClient({
-    options,
-    modelMeta: MODEL_META,
-    schemas: options.validate ? SCHEMAS : undefined,
-  }) as unknown as VibeClientInstance;
-}
-`);
-
-  return parts.join("\n");
-}
-
-function generateClientProperty(params: { model: Model }): string {
-  const { model } = params;
-  const modelVar = toCamelCase({ str: model.name });
-
-  return `  /**
-   * Operations for the ${model.name} model.
-   *
-   * @example
-   * const rows = await db.${modelVar}.findMany();
-   *
-   * @example
-   * const filteredRows = await db.${modelVar}.findMany({
-   *   where: {
-   *     // Add ${model.name}-specific filters here
-   *   },
-   * });
-   *
-   * @example
-   * const page = await db.${modelVar}.findMany({
-   *   where: {
-   *     // Add ${model.name}-specific filters here
-   *   },
-   *   orderBy: {
-   *     // e.g. createdAt: "desc"
-   *   },
-   *   take: 20,
-   *   skip: 0,
-   * });
-   */
-  ${modelVar}: ${model.name}Delegate;`;
-}
-
-function generateModelMeta(params: { schema: Schema }): string {
-  const { schema } = params;
-
-  const modelEntries = schema.models.map((model) => {
-    const scalarFields = model.fields
-      .filter((f) => f.kind === "scalar" || f.kind === "enum")
-      .map((f) => {
-        const dbName = f.kind === "scalar" ? f.dbName : f.dbName;
-        const isUpdatedAt = f.kind === "scalar" && f.isUpdatedAt;
-        const extras: string[] = [];
-        if (isUpdatedAt) extras.push(`isUpdatedAt: true`);
-        if (f.kind === "scalar") extras.push(`type: "${f.prismaType}"`);
-        if (f.isList) extras.push(`isList: true`);
-
-        // Emit default kind for application-level generation (uuid, cuid, nanoid, ulid)
-        if (f.default) {
-          const appLevelDefaults = new Set(["uuid", "cuid", "nanoid", "ulid"]);
-          if (appLevelDefaults.has(f.default.kind)) {
-            extras.push(`hasDefault: "${f.default.kind}"`);
-          } else if (f.default.kind !== "dbgenerated") {
-            // autoincrement, now, literal — DB handles these, but runtime should know
-            extras.push(`hasDefault: true`);
-          }
-        }
-
-        // Extract @vibeorm.idPrefix from documentation comment
-        const doc = (f.kind === "scalar" || f.kind === "enum") ? f.documentation : undefined;
-        if (doc) {
-          const prefixMatch = doc.match(/@vibeorm\.idPrefix\(["']([^"']+)["']\)/);
-          if (prefixMatch) {
-            extras.push(`idPrefix: "${prefixMatch[1]}"`);
-          }
-        }
-
-        const extraStr = extras.length > 0 ? `, ${extras.join(", ")}` : "";
-        return `      { name: "${f.name}", dbName: "${dbName}", kind: "${f.kind}" as const${extraStr} }`;
-      });
-
-    const relationFields = model.fields
-      .filter((f) => f.kind === "relation")
-      .map((f) => {
-        if (f.kind !== "relation") return "";
-        const isM2M = f.relation.type === "manyToMany";
-        let joinTableLine = "";
-        if (isM2M) {
-          const sorted = [model.name, f.relatedModel].sort();
-          const jtName = `_${sorted[0]}To${sorted[1]}`;
-          joinTableLine = `\n        joinTable: "${jtName}",`;
-        }
-        const relationNameLine = f.relation.name
-          ? `\n        relationName: "${f.relation.name}",`
-          : "";
-        return `      {
-        name: "${f.name}",
-        kind: "relation" as const,
-        relatedModel: "${f.relatedModel}",
-        type: "${f.relation.type}" as const,
-        isList: ${f.isList},
-        isForeignKey: ${f.relation.isForeignKey},
-        fields: ${JSON.stringify(f.relation.fields)},
-        references: ${JSON.stringify(f.relation.references)},${relationNameLine}${joinTableLine}
-      }`;
-      });
-
-    const pkFields = JSON.stringify(model.primaryKey.fields);
-    const uniqueFields = model.fields
-      .filter((f) => (f.kind === "scalar" || f.kind === "enum") && f.isUnique)
-      .map((f) => `"${f.name}"`);
-
-    return `  ${toCamelCase({ str: model.name })}: {
-    name: "${model.name}",
-    dbName: "${model.dbName}",
-    primaryKey: ${pkFields},
-    uniqueFields: [${uniqueFields.join(", ")}],
-    scalarFields: [
-${scalarFields.join(",\n")}
-    ],
-    relationFields: [
-${relationFields.join(",\n")}
-    ],
-  }`;
-  });
-
-  return `const MODEL_META = {
-${modelEntries.join(",\n")}
-} as const;
-`;
-}
-
-function generateSchemasMap(params: { schema: Schema }): string {
-  const { schema } = params;
-
-  const entries = schema.models.map((model) => {
-    const key = toCamelCase({ str: model.name });
-    return `  ${key}: {
-    model: ${model.name}Schema,
-    createInput: ${model.name}CreateInputSchema,
-    updateInput: ${model.name}UpdateInputSchema,
-    whereInput: ${model.name}WhereInputSchema,
-  }`;
-  });
-
-  return `const SCHEMAS = {
-${entries.join(",\n")}
-};
-`;
-}