@vibeorm/generator 1.3.1 → 2.0.0-alpha.10

package/dist/type-names.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Scalar → TypeScript type mapping and the shared filter/update-operation type
+ * names referenced by the emitted d.ts. Payload types mirror the runtime codec
+ * table exactly (BigInt → bigint, Decimal → string, DateTime → Date, Json →
+ * JsonValue, Bytes → Uint8Array); input types are wider where every dialect
+ * coerces (`Date | string`, `bigint | number`, `string | number` for Decimal).
+ */
+import type { ScalarType } from "@vibeorm/schema";
+import type { FieldView } from "./schema-view.ts";
+/** Scalars that take atomic update operations (increment/decrement/multiply/divide). */
+export declare const NUMERIC_SCALARS: ReadonlySet<ScalarType>;
+/** Scalars aggregable with `_min`/`_max` (orderable on every dialect). */
+export declare const MINMAX_SCALARS: ReadonlySet<ScalarType>;
+/** The payload type of a field WITHOUT list/null decoration (`string`, `Role`, …). */
+export declare function payloadBaseType(params: {
+    field: FieldView;
+}): string;
+/** The accepted input value type of a field WITHOUT list/null decoration. */
+export declare function inputBaseType(params: {
+    field: FieldView;
+}): string;
+/** The filter type name for a field (`StringFilter`, `RoleNullableFilter`, `IntListFilter`, …). */
+export declare function filterName(params: {
+    field: FieldView;
+}): string;
+/** The atomic update-operations type name for a numeric field, else `null`. */
+export declare function updateOpsName(params: {
+    field: FieldView;
+}): string | null;
+//# sourceMappingURL=type-names.d.ts.map

package/dist/type-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-names.d.ts","sourceRoot":"","sources":["../src/type-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AA+ClD,wFAAwF;AACxF,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,UAAU,CAAkD,CAAC;AAEvG,0EAA0E;AAC1E,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,UAAU,CAOjD,CAAC;AAIH,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG,MAAM,CAKpE;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG,MAAM,CAKlE;AAED,mGAAmG;AACnG,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG,MAAM,CAK/D;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAKzE"}

package/dist/util.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared helpers for the generator: naming, TS property keys, and the stable
+ * JSON serializer that keeps emitted output byte-identical for structurally
+ * identical IR (object-key insertion order never leaks into the output).
+ */
+/** First character uppercased, rest untouched (`posts` → `Posts`). */
+export declare function pascal(params: {
+    name: string;
+}): string;
+/**
+ * Delegate key for a model name: first character lowercased, rest untouched
+ * (the Prisma convention — mirrors @vibeorm/runtime's `toClientName`, which the
+ * generator must never drift from: the emitted d.ts declares exactly the
+ * properties the runtime attaches).
+ */
+export declare function clientNameOf(params: {
+    name: string;
+}): string;
+/** A field name as a TS property key — bare when it is a valid identifier, quoted otherwise. */
+export declare function propKey(params: {
+    name: string;
+}): string;
+/** A TS/JS double-quoted string literal, escaped. */
+export declare function tsString(params: {
+    value: string;
+}): string;
+/** Wrap a type expression in parens when it is a union (for `[]` suffixing). */
+export declare function maybeParens(params: {
+    type: string;
+}): string;
+/**
+ * JSON.stringify with recursively sorted object keys and 2-space indentation.
+ * Arrays keep their order (array order is semantic in the IR); `undefined`
+ * object values are omitted exactly like JSON.stringify does.
+ */
+export declare function stableStringify(params: {
+    value: unknown;
+}): string;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,sEAAsE;AACtE,wBAAgB,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAIvD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAI7D;AAID,gGAAgG;AAChG,wBAAgB,OAAO,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAGxD;AAED,qDAAqD;AACrD,wBAAgB,QAAQ,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE1D;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAG5D;AAID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAElE"}

package/package.json

@@ -1,42 +1,50 @@
 {
   "name": "@vibeorm/generator",
-  "version": "1.3.1",
-  "description": "TypeScript client generator for VibeORM — produces typed delegates, inputs, and Zod schemas from a Prisma schema",
-  "license": "MIT",
+  "version": "2.0.0-alpha.10",
+  "description": "Client generator for VibeORM v2 — emits .js + directly-written .d.ts from the Schema IR",
   "keywords": [
     "orm",
-    "codegen",
-    "prisma",
-    "bun",
     "typescript",
-    "postgresql"
+    "sql",
+    "database",
+    "bun",
+    "type-safe",
+    "codegen",
+    "client",
+    "typescript-codegen",
+    "declaration-files"
   ],
+  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/generator#readme",
+  "bugs": {
+    "url": "https://github.com/vibeorm/vibeorm/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vibeorm/vibeorm.git",
+    "directory": "packages/generator"
+  },
+  "license": "MIT",
+  "author": "VibeORM contributors",
   "type": "module",
   "exports": {
     ".": {
-      "default": "./src/index.ts",
-      "types": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "files": [
-    "src"
+    "dist",
+    "README.md"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/vibeorm/vibeorm.git",
-    "directory": "packages/generator"
+  "engines": {
+    "node": ">=18",
+    "bun": ">=1.2.0"
   },
-  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/generator",
-  "bugs": {
-    "url": "https://github.com/vibeorm/vibeorm/issues"
+  "dependencies": {
+    "@vibeorm/schema": "2.0.0-alpha.8",
+    "@vibeorm/sql": "2.0.0-alpha.8"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "engines": {
-    "bun": ">=1.1.0"
-  },
-  "dependencies": {
-    "@vibeorm/parser": "1.3.1"
   }
 }

package/src/generate.ts

@@ -1,70 +0,0 @@
-import type { Schema } from "@vibeorm/parser";
-import { generateEnums } from "./generators/generate-enums.ts";
-import { generateModels } from "./generators/generate-models.ts";
-import {
-  generateInputs,
-  generateFilterTypes,
-  generateRelationFilterTypes,
-} from "./generators/generate-inputs.ts";
-import { generateArgs } from "./generators/generate-args.ts";
-import { generateResult } from "./generators/generate-result.ts";
-import { generateDelegates } from "./generators/generate-delegates.ts";
-import { generateClient } from "./generators/generate-client.ts";
-import { generateSchemas } from "./generators/generate-schemas.ts";
-import { generateViewTypes } from "./generators/generate-view-types.ts";
-
-export type GeneratedFile = {
-  filename: string;
-  content: string;
-};
-
-/**
- * Takes a parsed schema IR and produces all the generated TypeScript files.
- */
-export function generate(params: { schema: Schema }): GeneratedFile[] {
-  const { schema } = params;
-
-  const files: GeneratedFile[] = [
-    {
-      filename: "enums.ts",
-      content: generateEnums({ enums: schema.enums }),
-    },
-    {
-      filename: "models.ts",
-      content: generateModels({ schema }),
-    },
-    {
-      filename: "inputs.ts",
-      content:
-        generateInputs({ schema }) +
-        generateFilterTypes() +
-        generateRelationFilterTypes({ schema }),
-    },
-    {
-      filename: "args.ts",
-      content: generateArgs({ schema }),
-    },
-    {
-      filename: "result.ts",
-      content: generateResult({ schema }),
-    },
-    {
-      filename: "delegates.ts",
-      content: generateDelegates({ schema }),
-    },
-    {
-      filename: "index.ts",
-      content: generateClient({ schema }),
-    },
-    {
-      filename: "schemas.ts",
-      content: generateSchemas({ schema }),
-    },
-    {
-      filename: "view-types.ts",
-      content: generateViewTypes({ schema }),
-    },
-  ];
-
-  return files;
-}

package/src/generators/generate-args.ts

@@ -1,322 +0,0 @@
-import type { Model, Schema, RelationField, ScalarField } from "@vibeorm/parser";
-import { fileHeader } from "../utils.ts";
-
-/**
- * Generates Select, Include, and Args types for each model,
- * plus the FindManyArgs, FindFirstArgs, FindUniqueArgs, etc.
- */
-export function generateArgs(params: { schema: Schema }): string {
-  const { schema } = params;
-  const parts: string[] = [fileHeader()];
-
-  // Imports
-  const modelImports = schema.models.map((m) => `${m.name}WhereInput, ${m.name}WhereUniqueInput, ${m.name}OrderByInput, ${m.name}CreateInput, ${m.name}UpdateInput`).join(", ");
-  parts.push(`import type { ${modelImports}, SortOrder, SortOrderWithNulls } from "./inputs.ts";`);
-
-  const payloadImports = schema.models.map((m) => `$${m.name}Payload`).join(", ");
-  parts.push(`import type { ${payloadImports}, OperationPayload } from "./models.ts";\n`);
-
-  // Shared types
-  parts.push(`export type RelationStrategy = "query" | "join";
-
-export type NumberWithAggregatesFilter = {
-  equals?: number;
-  not?: number;
-  lt?: number;
-  lte?: number;
-  gt?: number;
-  gte?: number;
-};
-`);
-
-  // Generate Select + Include + Args for each model
-  for (const model of schema.models) {
-    parts.push(generateSelectType({ model, schema }));
-    parts.push(generateIncludeType({ model, schema }));
-    parts.push(generateOperationArgs({ model }));
-    parts.push(generateAggregateInputTypes({ model }));
-  }
-
-  return parts.join("\n");
-}
-
-// ─── Select Type ──────────────────────────────────────────────────
-
-function generateSelectType(params: {
-  model: Model;
-  schema: Schema;
-}): string {
-  const { model, schema } = params;
-
-  const entries: string[] = [];
-
-  for (const field of model.fields) {
-    if (field.kind === "scalar" || field.kind === "enum") {
-      entries.push(`  ${field.name}?: boolean;`);
-    } else if (field.kind === "relation") {
-      if (field.isList) {
-        entries.push(`  ${field.name}?: boolean | ${field.relatedModel}FindManyArgs;`);
-      } else {
-        entries.push(`  ${field.name}?: boolean | ${field.relatedModel}FindFirstArgs;`);
-      }
-    }
-  }
-
-  // Add _count support for relation counting
-  const countableRelations = model.fields.filter(
-    (f): f is RelationField => f.kind === "relation" && f.isList
-  );
-  if (countableRelations.length > 0) {
-    const countFields = countableRelations.map((f) => `    ${f.name}?: boolean;`);
-    entries.push(`  _count?: boolean | {\n    select?: {\n${countFields.join("\n")}\n    };\n  };`);
-  }
-
-  return `export type ${model.name}Select = {
-${entries.join("\n")}
-};
-`;
-}
-
-// ─── Include Type ─────────────────────────────────────────────────
-
-function generateIncludeType(params: {
-  model: Model;
-  schema: Schema;
-}): string {
-  const { model } = params;
-
-  const relationFields = model.fields.filter(
-    (f): f is RelationField => f.kind === "relation"
-  );
-
-  if (relationFields.length === 0) {
-    return `export type ${model.name}Include = Record<string, never>;\n`;
-  }
-
-  const entries = relationFields.map((f) => {
-    if (f.isList) {
-      return `  ${f.name}?: boolean | ${f.relatedModel}FindManyArgs;`;
-    }
-    return `  ${f.name}?: boolean | ${f.relatedModel}FindFirstArgs;`;
-  });
-
-  // Add _count support for relation counting
-  const countableRelations = relationFields.filter((f) => f.isList);
-  if (countableRelations.length > 0) {
-    const countFields = countableRelations.map((f) => `    ${f.name}?: boolean;`);
-    entries.push(`  _count?: boolean | {\n    select?: {\n${countFields.join("\n")}\n    };\n  };`);
-  }
-
-  return `export type ${model.name}Include = {
-${entries.join("\n")}
-};
-`;
-}
-
-// ─── Operation Args ───────────────────────────────────────────────
-
-function generateOperationArgs(params: { model: Model }): string {
-  const { model } = params;
-
-  // Omit type — inverse of select (exclude specific fields)
-  const scalarFieldNames = model.fields
-    .filter((f) => f.kind === "scalar" || f.kind === "enum")
-    .map((f) => `  ${f.name}?: boolean;`);
-
-  const omitTypeDef = `export type ${model.name}Omit = {
-${scalarFieldNames.join("\n")}
-};
-`;
-
-  return `${omitTypeDef}
-export type ${model.name}FindManyArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-  distinct?: (keyof ${model.name}Select)[];
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}FindFirstArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}FindUniqueArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where: ${model.name}WhereUniqueInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}CreateArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  data: ${model.name}CreateInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}UpdateArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where: ${model.name}WhereUniqueInput;
-  data: ${model.name}UpdateInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}UpsertArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  where: ${model.name}WhereUniqueInput;
-  create: ${model.name}CreateInput;
-  update: ${model.name}UpdateInput;
-};
-
-export type ${model.name}DeleteArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  where: ${model.name}WhereUniqueInput;
-};
-
-export type ${model.name}DeleteManyArgs = {
-  where?: ${model.name}WhereInput;
-};
-
-export type ${model.name}CountArgs = {
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-};
-
-export type ${model.name}CreateManyArgs = {
-  data: ${model.name}CreateInput | ${model.name}CreateInput[];
-  skipDuplicates?: boolean;
-};
-
-export type ${model.name}CreateManyAndReturnArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  data: ${model.name}CreateInput | ${model.name}CreateInput[];
-  skipDuplicates?: boolean;
-};
-
-export type ${model.name}UpdateManyArgs = {
-  where?: ${model.name}WhereInput;
-  data: ${model.name}UpdateInput;
-};
-
-export type ${model.name}AggregateArgs = {
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-  _count?: true | ${model.name}CountAggregateInputType;
-  _avg?: ${model.name}AvgAggregateInputType;
-  _sum?: ${model.name}SumAggregateInputType;
-  _min?: ${model.name}MinAggregateInputType;
-  _max?: ${model.name}MaxAggregateInputType;
-};
-
-export type ${model.name}GroupByArgs = {
-  by: (keyof ${model.name}Select)[];
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  having?: ${model.name}ScalarWhereWithAggregatesInput;
-  take?: number;
-  skip?: number;
-  _count?: true | ${model.name}CountAggregateInputType;
-  _avg?: ${model.name}AvgAggregateInputType;
-  _sum?: ${model.name}SumAggregateInputType;
-  _min?: ${model.name}MinAggregateInputType;
-  _max?: ${model.name}MaxAggregateInputType;
-};
-`;
-}
-
-// ─── Aggregate Input Types ────────────────────────────────────────
-
-const NUMERIC_PRISMA_TYPES = new Set(["Int", "Float", "Decimal", "BigInt"]);
-
-function generateAggregateInputTypes(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)
-  );
-
-  // CountAggregateInputType — all scalar fields + _all
-  const countEntries = [
-    `  _all?: boolean;`,
-    ...scalarFields.map((f) => `  ${f.name}?: boolean;`),
-  ];
-
-  // AvgAggregateInputType — only numeric fields
-  const avgEntries = numericFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // SumAggregateInputType — only numeric fields
-  const sumEntries = numericFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // MinAggregateInputType — all scalar fields
-  const minEntries = scalarFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // MaxAggregateInputType — all scalar fields
-  const maxEntries = scalarFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // ScalarWhereWithAggregatesInput — for HAVING clause in groupBy
-  const havingEntries = scalarFields.map((f) => {
-    return `  ${f.name}?: {
-    _count?: NumberWithAggregatesFilter;
-    _avg?: NumberWithAggregatesFilter;
-    _sum?: NumberWithAggregatesFilter;
-    _min?: NumberWithAggregatesFilter;
-    _max?: NumberWithAggregatesFilter;
-  };`;
-  });
-
-  return `export type ${model.name}CountAggregateInputType = {
-${countEntries.join("\n")}
-};
-
-export type ${model.name}AvgAggregateInputType = {
-${avgEntries.length > 0 ? avgEntries.join("\n") : "  [key: string]: never;"}
-};
-
-export type ${model.name}SumAggregateInputType = {
-${sumEntries.length > 0 ? sumEntries.join("\n") : "  [key: string]: never;"}
-};
-
-export type ${model.name}MinAggregateInputType = {
-${minEntries.join("\n")}
-};
-
-export type ${model.name}MaxAggregateInputType = {
-${maxEntries.join("\n")}
-};
-
-export type ${model.name}ScalarWhereWithAggregatesInput = {
-${havingEntries.join("\n")}
-};
-`;
-}