@vibeorm/generator 1.0.0

package/src/generators/generate-models.ts

@@ -0,0 +1,103 @@
+import type { Model, Schema, Field, ScalarField, EnumField, RelationField } from "@vibeorm/parser";
+import { fileHeader, toCamelCase } from "../utils.ts";
+
+/**
+ * Generates the Payload types for each model.
+ * These split each model into { scalars, objects, composites }
+ * which is the foundation for select/include type narrowing.
+ */
+export function generateModels(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // Import enums if any
+  if (schema.enums.length > 0) {
+    const enumImports = schema.enums.map((e) => e.name).join(", ");
+    parts.push(`import type { ${enumImports} } from "./enums.ts";\n`);
+  }
+
+  // Generate JsonValue type
+  parts.push(`export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };\n`);
+
+  // Generate the base OperationPayload interface
+  parts.push(`export type OperationPayload = {
+  name: string;
+  scalars: Record<string, unknown>;
+  objects: Record<string, unknown>;
+  composites: Record<string, unknown>;
+};\n`);
+
+  // Generate payload type for each model
+  for (const model of schema.models) {
+    parts.push(generatePayloadType({ model, schema }));
+  }
+
+  // Generate plain model types (default selection = scalars only)
+  for (const model of schema.models) {
+    parts.push(generatePlainModelType({ model, schema }));
+  }
+
+  return parts.join("\n");
+}
+
+function generatePayloadType(params: { model: Model; schema: Schema }): string {
+  const { model, schema } = params;
+
+  const scalarFields = model.fields.filter(
+    (f): f is ScalarField | EnumField => f.kind === "scalar" || f.kind === "enum"
+  );
+  const relationFields = model.fields.filter(
+    (f): f is RelationField => f.kind === "relation"
+  );
+
+  // Scalars block
+  const scalarsEntries = scalarFields.map((f) => {
+    const tsType = f.kind === "scalar" ? f.tsType : f.enumName;
+    const nullable = f.isRequired ? "" : " | null";
+    const listPrefix = f.isList ? "" : "";
+    const listSuffix = f.isList ? "[]" : "";
+    return `    ${f.name}: ${listPrefix}${tsType}${nullable}${listSuffix};`;
+  });
+
+  // Objects block
+  const objectsEntries = relationFields.map((f) => {
+    const payloadType = `$${f.relatedModel}Payload`;
+    if (f.isList) {
+      return `    ${f.name}: ${payloadType}[];`;
+    }
+    const nullable = f.isRequired ? "" : " | null";
+    return `    ${f.name}: ${payloadType}${nullable};`;
+  });
+
+  return `export type $${model.name}Payload = {
+  name: "${model.name}";
+  scalars: {
+${scalarsEntries.join("\n")}
+  };
+  objects: {
+${objectsEntries.join("\n")}
+  };
+  composites: {};
+};
+`;
+}
+
+function generatePlainModelType(params: { model: Model; schema: Schema }): string {
+  const { model } = params;
+
+  const scalarFields = model.fields.filter(
+    (f): f is ScalarField | EnumField => f.kind === "scalar" || f.kind === "enum"
+  );
+
+  const entries = scalarFields.map((f) => {
+    const tsType = f.kind === "scalar" ? f.tsType : f.enumName;
+    const nullable = f.isRequired ? "" : " | null";
+    const listSuffix = f.isList ? "[]" : "";
+    return `  ${f.name}: ${tsType}${nullable}${listSuffix};`;
+  });
+
+  return `export type ${model.name} = {
+${entries.join("\n")}
+};
+`;
+}

package/src/generators/generate-result.ts

@@ -0,0 +1,163 @@
+import { fileHeader } from "../utils.ts";
+import type { Schema } from "@vibeorm/parser";
+
+/**
+ * Generates the core type resolution engine.
+ *
+ * This produces the conditional types that narrow return types
+ * based on the select/include args passed to operations.
+ *
+ * The pattern:
+ * - No select/include → DefaultSelection (scalars only)
+ * - select: { field: true } → only selected fields
+ * - include: { relation: true } → scalars + included relations
+ * - Nested select/include in relations → recursive narrowing
+ */
+export function generateResult(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // Import payload types
+  const payloadImports = schema.models
+    .map((m) => `$${m.name}Payload`)
+    .join(", ");
+  parts.push(
+    `import type { ${payloadImports}, OperationPayload } from "./models.ts";\n`
+  );
+
+  // ─── Utility Types ────────────────────────────────────────────────
+
+  parts.push(`
+// ─── Core Utility Types ───────────────────────────────────────────
+
+/** Detect if T is exactly \`any\` */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+
+/** Flatten intersection types for cleaner hover tooltips */
+type Compute<T> = T extends Function ? T : { [K in keyof T]: T[K] } & unknown;
+
+/** Extract scalar fields from a payload (default selection) */
+type DefaultSelection<P extends OperationPayload> = P["scalars"];
+
+/**
+ * Check if a key exists in the payload's objects or composites
+ * and extract the value type.
+ */
+type SelectableObject<P extends OperationPayload, K extends PropertyKey> =
+  K extends keyof P["objects"] ? P["objects"][K] : never;
+
+// ─── GetFindResult ────────────────────────────────────────────────
+
+/**
+ * The core type that resolves the result type based on select/include args.
+ *
+ * - If no args or args is any → DefaultSelection (scalars only)
+ * - If select is provided → only selected fields (scalars + expanded relations)
+ * - If include is provided → all scalars + included relations
+ */
+export type GetFindResult<P extends OperationPayload, A> =
+  // If Args is any (no args passed), return default
+  IsAny<A> extends true
+    ? DefaultSelection<P>
+    : A extends { select: infer S extends Record<string, unknown> }
+      ? // ── SELECT branch ──
+        Compute<{
+          [K in keyof S as S[K] extends false | undefined | null
+            ? never
+            : K]: K extends keyof P["scalars"]
+            ? // Scalar field selected
+              P["scalars"][K]
+            : K extends keyof P["objects"]
+              ? // Relation field selected
+                P["objects"][K] extends OperationPayload[]
+                ? // Array relation
+                  S[K] extends Record<string, unknown>
+                  ? GetFindResult<P["objects"][K][number], S[K]>[]
+                  : DefaultSelection<P["objects"][K][number]>[]
+                : P["objects"][K] extends OperationPayload | null
+                  ? // Nullable single relation
+                    S[K] extends Record<string, unknown>
+                    ? GetFindResult<NonNullable<P["objects"][K]> & OperationPayload, S[K]> | null
+                    : DefaultSelection<NonNullable<P["objects"][K]> & OperationPayload> | null
+                  : P["objects"][K] extends OperationPayload
+                    ? // Required single relation
+                      S[K] extends Record<string, unknown>
+                      ? GetFindResult<P["objects"][K], S[K]>
+                      : DefaultSelection<P["objects"][K]>
+                    : never
+              : never;
+        }>
+      : A extends { include: infer I extends Record<string, unknown> }
+        ? // ── INCLUDE branch ──
+          // All scalars + included relations
+          Compute<
+            DefaultSelection<P> & {
+              [K in keyof I as I[K] extends false | undefined | null
+                ? never
+                : K]: K extends keyof P["objects"]
+                ? P["objects"][K] extends OperationPayload[]
+                  ? // Array relation
+                    I[K] extends Record<string, unknown>
+                    ? GetFindResult<P["objects"][K][number], I[K]>[]
+                    : DefaultSelection<P["objects"][K][number]>[]
+                  : P["objects"][K] extends OperationPayload | null
+                    ? // Nullable single relation
+                      I[K] extends Record<string, unknown>
+                      ? GetFindResult<NonNullable<P["objects"][K]> & OperationPayload, I[K]> | null
+                      : DefaultSelection<NonNullable<P["objects"][K]> & OperationPayload> | null
+                    : P["objects"][K] extends OperationPayload
+                      ? // Required single relation
+                        I[K] extends Record<string, unknown>
+                        ? GetFindResult<P["objects"][K], I[K]>
+                        : DefaultSelection<P["objects"][K]>
+                      : never
+                : never;
+            }
+          >
+        : // ── No select/include ──
+          DefaultSelection<P>;
+
+// ─── Operation Result Types ───────────────────────────────────────
+
+/**
+ * Maps an operation name to the correct result cardinality.
+ */
+export type GetResult<
+  P extends OperationPayload,
+  A,
+  Op extends string,
+> = {
+  findMany: GetFindResult<P, A>[];
+  findFirst: GetFindResult<P, A> | null;
+  findUnique: GetFindResult<P, A> | null;
+  findUniqueOrThrow: GetFindResult<P, A>;
+  findFirstOrThrow: GetFindResult<P, A>;
+  create: GetFindResult<P, A>;
+  createMany: { count: number };
+  createManyAndReturn: GetFindResult<P, A>[];
+  update: GetFindResult<P, A>;
+  upsert: GetFindResult<P, A>;
+  delete: GetFindResult<P, A>;
+  count: number;
+  deleteMany: { count: number };
+  updateMany: { count: number };
+}[Op & keyof {
+  findMany: unknown;
+  findFirst: unknown;
+  findUnique: unknown;
+  findUniqueOrThrow: unknown;
+  findFirstOrThrow: unknown;
+  create: unknown;
+  createMany: unknown;
+  createManyAndReturn: unknown;
+  update: unknown;
+  upsert: unknown;
+  delete: unknown;
+  count: unknown;
+  deleteMany: unknown;
+  updateMany: unknown;
+}];
+`);
+
+  return parts.join("\n");
+}