@prisma/ts-builders 6.6.0-dev.59

package/dist/Property.test.mjs

@@ -0,0 +1,36 @@
+import { expect, test } from "vitest";
+import { docComment } from "./DocComment";
+import { namedType } from "./NamedType";
+import { property } from "./Property";
+import { stringify } from "./stringify";
+import { toStringTag } from "./WellKnownSymbol";
+const A = namedType("A");
+test("name and type", () => {
+  const prop = property("foo", A);
+  expect(stringify(prop)).toMatchInlineSnapshot(`"foo: A"`);
+});
+test("invalid identifier", () => {
+  const prop = property("this is not a valid JS identifier", A);
+  expect(stringify(prop)).toMatchInlineSnapshot(`"["this is not a valid JS identifier"]: A"`);
+});
+test("well-known symbol", () => {
+  const prop = property(toStringTag, A);
+  expect(stringify(prop)).toMatchInlineSnapshot(`"[Symbol.toStringTag]: A"`);
+});
+test("optional", () => {
+  const prop = property("foo", A).optional();
+  expect(stringify(prop)).toMatchInlineSnapshot(`"foo?: A"`);
+});
+test("readonly", () => {
+  const prop = property("foo", A).readonly();
+  expect(stringify(prop)).toMatchInlineSnapshot(`"readonly foo: A"`);
+});
+test("with doc comment", () => {
+  const prop = property("foo", A).setDocComment(docComment("This is foo"));
+  expect(stringify(prop)).toMatchInlineSnapshot(`
+    "/**
+     * This is foo
+     */
+    foo: A"
+  `);
+});

package/dist/StringLiteralType.d.ts

@@ -0,0 +1,8 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class StringLiteralType extends TypeBuilder {
+    readonly content: string;
+    constructor(content: string);
+    write(writer: Writer): void;
+}
+export declare function stringLiteral(content: string): StringLiteralType;

package/dist/StringLiteralType.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var StringLiteralType_exports = {};
+__export(StringLiteralType_exports, {
+  StringLiteralType: () => StringLiteralType,
+  stringLiteral: () => stringLiteral
+});
+module.exports = __toCommonJS(StringLiteralType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class StringLiteralType extends import_TypeBuilder.TypeBuilder {
+  constructor(content) {
+    super();
+    this.content = content;
+  }
+  write(writer) {
+    writer.write(JSON.stringify(this.content));
+  }
+}
+function stringLiteral(content) {
+  return new StringLiteralType(content);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StringLiteralType,
+  stringLiteral
+});

package/dist/StringLiteralType.mjs

@@ -0,0 +1,17 @@
+import { TypeBuilder } from "./TypeBuilder";
+class StringLiteralType extends TypeBuilder {
+  constructor(content) {
+    super();
+    this.content = content;
+  }
+  write(writer) {
+    writer.write(JSON.stringify(this.content));
+  }
+}
+function stringLiteral(content) {
+  return new StringLiteralType(content);
+}
+export {
+  StringLiteralType,
+  stringLiteral
+};

package/dist/TupleType.d.ts

@@ -0,0 +1,17 @@
+import { BasicBuilder } from './BasicBuilder';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class TupleItem implements BasicBuilder {
+    readonly type: TypeBuilder;
+    private name;
+    constructor(type: TypeBuilder);
+    setName(name: string): this;
+    write(writer: Writer<undefined>): void;
+}
+export declare class TupleType extends TypeBuilder {
+    readonly items: TupleItem[];
+    add(item: TypeBuilder | TupleItem): this;
+    write(writer: Writer): void;
+}
+export declare function tupleType(): TupleType;
+export declare function tupleItem(type: TypeBuilder): TupleItem;

package/dist/TupleType.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TupleType_exports = {};
+__export(TupleType_exports, {
+  TupleItem: () => TupleItem,
+  TupleType: () => TupleType,
+  tupleItem: () => tupleItem,
+  tupleType: () => tupleType
+});
+module.exports = __toCommonJS(TupleType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class TupleItem {
+  constructor(type) {
+    this.type = type;
+  }
+  name;
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  write(writer) {
+    if (this.name) {
+      writer.write(this.name).write(": ");
+    }
+    writer.write(this.type);
+  }
+}
+class TupleType extends import_TypeBuilder.TypeBuilder {
+  items = [];
+  add(item) {
+    if (item instanceof import_TypeBuilder.TypeBuilder) {
+      item = new TupleItem(item);
+    }
+    this.items.push(item);
+    return this;
+  }
+  write(writer) {
+    writer.write("[").writeJoined(", ", this.items).write("]");
+  }
+}
+function tupleType() {
+  return new TupleType();
+}
+function tupleItem(type) {
+  return new TupleItem(type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TupleItem,
+  TupleType,
+  tupleItem,
+  tupleType
+});

package/dist/TupleType.mjs

@@ -0,0 +1,42 @@
+import { TypeBuilder } from "./TypeBuilder";
+class TupleItem {
+  constructor(type) {
+    this.type = type;
+  }
+  name;
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  write(writer) {
+    if (this.name) {
+      writer.write(this.name).write(": ");
+    }
+    writer.write(this.type);
+  }
+}
+class TupleType extends TypeBuilder {
+  items = [];
+  add(item) {
+    if (item instanceof TypeBuilder) {
+      item = new TupleItem(item);
+    }
+    this.items.push(item);
+    return this;
+  }
+  write(writer) {
+    writer.write("[").writeJoined(", ", this.items).write("]");
+  }
+}
+function tupleType() {
+  return new TupleType();
+}
+function tupleItem(type) {
+  return new TupleItem(type);
+}
+export {
+  TupleItem,
+  TupleType,
+  tupleItem,
+  tupleType
+};

package/dist/TupleType.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/TupleType.test.js

@@ -0,0 +1,21 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+var import_TupleType = require("./TupleType");
+(0, import_vitest.test)("empty", () => {
+  const tuple = (0, import_TupleType.tupleType)();
+  (0, import_vitest.expect)((0, import_stringify.stringify)(tuple)).toMatchInlineSnapshot(`"[]"`);
+});
+(0, import_vitest.test)("one item", () => {
+  const tuple = (0, import_TupleType.tupleType)().add((0, import_NamedType.namedType)("A"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(tuple)).toMatchInlineSnapshot(`"[A]"`);
+});
+(0, import_vitest.test)("with named item", () => {
+  const tuple = (0, import_TupleType.tupleType)().add((0, import_TupleType.tupleItem)((0, import_NamedType.namedType)("A")).setName("foo"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(tuple)).toMatchInlineSnapshot(`"[foo: A]"`);
+});
+(0, import_vitest.test)("multiple items", () => {
+  const tuple = (0, import_TupleType.tupleType)().add((0, import_NamedType.namedType)("A")).add((0, import_NamedType.namedType)("B")).add((0, import_NamedType.namedType)("C"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(tuple)).toMatchInlineSnapshot(`"[A, B, C]"`);
+});

package/dist/TupleType.test.mjs

@@ -0,0 +1,20 @@
+import { expect, test } from "vitest";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+import { tupleItem, tupleType } from "./TupleType";
+test("empty", () => {
+  const tuple = tupleType();
+  expect(stringify(tuple)).toMatchInlineSnapshot(`"[]"`);
+});
+test("one item", () => {
+  const tuple = tupleType().add(namedType("A"));
+  expect(stringify(tuple)).toMatchInlineSnapshot(`"[A]"`);
+});
+test("with named item", () => {
+  const tuple = tupleType().add(tupleItem(namedType("A")).setName("foo"));
+  expect(stringify(tuple)).toMatchInlineSnapshot(`"[foo: A]"`);
+});
+test("multiple items", () => {
+  const tuple = tupleType().add(namedType("A")).add(namedType("B")).add(namedType("C"));
+  expect(stringify(tuple)).toMatchInlineSnapshot(`"[A, B, C]"`);
+});

package/dist/TypeBuilder.d.ts

@@ -0,0 +1,11 @@
+import { BasicBuilder } from './BasicBuilder';
+import type { KeyType } from './KeyType';
+import { Writer } from './Writer';
+export declare abstract class TypeBuilder implements BasicBuilder {
+    needsParenthesisWhenIndexed: boolean;
+    needsParenthesisInKeyof: boolean;
+    needsParenthesisInUnion: boolean;
+    abstract write(writer: Writer): void;
+    subKey(key: string): KeyType;
+    writeIndexed(writer: Writer): void;
+}

package/dist/TypeBuilder.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TypeBuilder_exports = {};
+__export(TypeBuilder_exports, {
+  TypeBuilder: () => TypeBuilder
+});
+module.exports = __toCommonJS(TypeBuilder_exports);
+class TypeBuilder {
+  // TODO(@SevInf): this should be replaced with precedence system that would
+  // automatically add parenthesis where they are needed
+  needsParenthesisWhenIndexed = false;
+  needsParenthesisInKeyof = false;
+  needsParenthesisInUnion = false;
+  subKey(key) {
+    const { KeyType } = require("./KeyType");
+    return new KeyType(this, key);
+  }
+  writeIndexed(writer) {
+    if (this.needsParenthesisWhenIndexed) {
+      writer.write("(");
+    }
+    writer.write(this);
+    if (this.needsParenthesisWhenIndexed) {
+      writer.write(")");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeBuilder
+});

package/dist/TypeBuilder.mjs

@@ -0,0 +1,23 @@
+class TypeBuilder {
+  // TODO(@SevInf): this should be replaced with precedence system that would
+  // automatically add parenthesis where they are needed
+  needsParenthesisWhenIndexed = false;
+  needsParenthesisInKeyof = false;
+  needsParenthesisInUnion = false;
+  subKey(key) {
+    const { KeyType } = require("./KeyType");
+    return new KeyType(this, key);
+  }
+  writeIndexed(writer) {
+    if (this.needsParenthesisWhenIndexed) {
+      writer.write("(");
+    }
+    writer.write(this);
+    if (this.needsParenthesisWhenIndexed) {
+      writer.write(")");
+    }
+  }
+}
+export {
+  TypeBuilder
+};

package/dist/TypeDeclaration.d.ts

@@ -0,0 +1,17 @@
+import { BasicBuilder } from './BasicBuilder';
+import { DocComment } from './DocComment';
+import { GenericParameter } from './GenericParameter';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class TypeDeclaration<InnerType extends TypeBuilder = TypeBuilder> implements BasicBuilder {
+    name: string;
+    readonly type: InnerType;
+    private genericParameters;
+    private docComment?;
+    constructor(name: string, type: InnerType);
+    addGenericParameter(param: GenericParameter): this;
+    setName(name: string): this;
+    setDocComment(docComment: DocComment): this;
+    write(writer: Writer): void;
+}
+export declare function typeDeclaration<InnerType extends TypeBuilder = TypeBuilder>(name: string, type: InnerType): TypeDeclaration<InnerType>;

package/dist/TypeDeclaration.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TypeDeclaration_exports = {};
+__export(TypeDeclaration_exports, {
+  TypeDeclaration: () => TypeDeclaration,
+  typeDeclaration: () => typeDeclaration
+});
+module.exports = __toCommonJS(TypeDeclaration_exports);
+class TypeDeclaration {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  genericParameters = [];
+  docComment;
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write("type ").write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write(" = ").write(this.type);
+  }
+}
+function typeDeclaration(name, type) {
+  return new TypeDeclaration(name, type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeDeclaration,
+  typeDeclaration
+});

package/dist/TypeDeclaration.mjs

@@ -0,0 +1,37 @@
+class TypeDeclaration {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  genericParameters = [];
+  docComment;
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write("type ").write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write(" = ").write(this.type);
+  }
+}
+function typeDeclaration(name, type) {
+  return new TypeDeclaration(name, type);
+}
+export {
+  TypeDeclaration,
+  typeDeclaration
+};

package/dist/TypeDeclaration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/TypeDeclaration.test.js

@@ -0,0 +1,28 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_DocComment = require("./DocComment");
+var import_GenericParameter = require("./GenericParameter");
+var import_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+var import_TypeDeclaration = require("./TypeDeclaration");
+const A = (0, import_NamedType.namedType)("A");
+(0, import_vitest.test)("basic", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_TypeDeclaration.typeDeclaration)("B", A))).toMatchInlineSnapshot(`"type B = A"`);
+});
+(0, import_vitest.test)("with doc comment", () => {
+  const decl = (0, import_TypeDeclaration.typeDeclaration)("B", A).setDocComment((0, import_DocComment.docComment)("Type for stuff"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(decl)).toMatchInlineSnapshot(`
+    "/**
+     * Type for stuff
+     */
+    type B = A"
+  `);
+});
+(0, import_vitest.test)("with generic parameters", () => {
+  const decl = (0, import_TypeDeclaration.typeDeclaration)("B", A).addGenericParameter((0, import_GenericParameter.genericParameter)("T"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(decl)).toMatchInlineSnapshot(`"type B<T> = A"`);
+});
+(0, import_vitest.test)("with multiple generic parameters", () => {
+  const decl = (0, import_TypeDeclaration.typeDeclaration)("B", A).addGenericParameter((0, import_GenericParameter.genericParameter)("T")).addGenericParameter((0, import_GenericParameter.genericParameter)("U"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(decl)).toMatchInlineSnapshot(`"type B<T, U> = A"`);
+});

package/dist/TypeDeclaration.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+import { docComment } from "./DocComment";
+import { genericParameter } from "./GenericParameter";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+import { typeDeclaration } from "./TypeDeclaration";
+const A = namedType("A");
+test("basic", () => {
+  expect(stringify(typeDeclaration("B", A))).toMatchInlineSnapshot(`"type B = A"`);
+});
+test("with doc comment", () => {
+  const decl = typeDeclaration("B", A).setDocComment(docComment("Type for stuff"));
+  expect(stringify(decl)).toMatchInlineSnapshot(`
+    "/**
+     * Type for stuff
+     */
+    type B = A"
+  `);
+});
+test("with generic parameters", () => {
+  const decl = typeDeclaration("B", A).addGenericParameter(genericParameter("T"));
+  expect(stringify(decl)).toMatchInlineSnapshot(`"type B<T> = A"`);
+});
+test("with multiple generic parameters", () => {
+  const decl = typeDeclaration("B", A).addGenericParameter(genericParameter("T")).addGenericParameter(genericParameter("U"));
+  expect(stringify(decl)).toMatchInlineSnapshot(`"type B<T, U> = A"`);
+});

package/dist/UnionType.d.ts

@@ -0,0 +1,13 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class UnionType<VariantType extends TypeBuilder = TypeBuilder> extends TypeBuilder {
+    needsParenthesisWhenIndexed: boolean;
+    needsParenthesisInKeyof: boolean;
+    readonly variants: VariantType[];
+    constructor(firstType: VariantType);
+    addVariant(variant: VariantType): this;
+    addVariants(variants: VariantType[]): this;
+    write(writer: Writer): void;
+    mapVariants<NewVariantType extends TypeBuilder>(callback: (type: VariantType) => NewVariantType): UnionType<NewVariantType>;
+}
+export declare function unionType<VariantType extends TypeBuilder = TypeBuilder>(types: VariantType[] | VariantType): UnionType<VariantType>;

package/dist/UnionType.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var UnionType_exports = {};
+__export(UnionType_exports, {
+  UnionType: () => UnionType,
+  unionType: () => unionType
+});
+module.exports = __toCommonJS(UnionType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class UnionType extends import_TypeBuilder.TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  needsParenthesisInKeyof = true;
+  variants;
+  constructor(firstType) {
+    super();
+    this.variants = [firstType];
+  }
+  addVariant(variant) {
+    this.variants.push(variant);
+    return this;
+  }
+  addVariants(variants) {
+    for (const variant of variants) {
+      this.addVariant(variant);
+    }
+    return this;
+  }
+  write(writer) {
+    writer.writeJoined(" | ", this.variants, (variant, writer2) => {
+      if (variant.needsParenthesisInUnion) {
+        writer2.write("(").write(variant).write(")");
+      } else {
+        writer2.write(variant);
+      }
+    });
+  }
+  mapVariants(callback) {
+    return unionType(this.variants.map((v) => callback(v)));
+  }
+}
+function unionType(types) {
+  if (Array.isArray(types)) {
+    if (types.length === 0) {
+      throw new TypeError("Union types array can not be empty");
+    }
+    const union = new UnionType(types[0]);
+    for (let i = 1; i < types.length; i++) {
+      union.addVariant(types[i]);
+    }
+    return union;
+  }
+  return new UnionType(types);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UnionType,
+  unionType
+});