@prisma/ts-builders 6.6.0-dev.100

package/dist/PrimitiveType.js

@@ -0,0 +1,70 @@
+"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 PrimitiveType_exports = {};
+__export(PrimitiveType_exports, {
+  PrimitiveType: () => PrimitiveType,
+  anyType: () => anyType,
+  bigintType: () => bigintType,
+  booleanType: () => booleanType,
+  neverType: () => neverType,
+  nullType: () => nullType,
+  numberType: () => numberType,
+  stringType: () => stringType,
+  thisType: () => thisType,
+  undefinedType: () => undefinedType,
+  unknownType: () => unknownType,
+  voidType: () => voidType
+});
+module.exports = __toCommonJS(PrimitiveType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class PrimitiveType extends import_TypeBuilder.TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  write(writer) {
+    writer.write(this.name);
+  }
+}
+const stringType = new PrimitiveType("string");
+const numberType = new PrimitiveType("number");
+const booleanType = new PrimitiveType("boolean");
+const nullType = new PrimitiveType("null");
+const undefinedType = new PrimitiveType("undefined");
+const bigintType = new PrimitiveType("bigint");
+const unknownType = new PrimitiveType("unknown");
+const anyType = new PrimitiveType("any");
+const voidType = new PrimitiveType("void");
+const thisType = new PrimitiveType("this");
+const neverType = new PrimitiveType("never");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrimitiveType,
+  anyType,
+  bigintType,
+  booleanType,
+  neverType,
+  nullType,
+  numberType,
+  stringType,
+  thisType,
+  undefinedType,
+  unknownType,
+  voidType
+});

package/dist/PrimitiveType.mjs

@@ -0,0 +1,35 @@
+import { TypeBuilder } from "./TypeBuilder";
+class PrimitiveType extends TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  write(writer) {
+    writer.write(this.name);
+  }
+}
+const stringType = new PrimitiveType("string");
+const numberType = new PrimitiveType("number");
+const booleanType = new PrimitiveType("boolean");
+const nullType = new PrimitiveType("null");
+const undefinedType = new PrimitiveType("undefined");
+const bigintType = new PrimitiveType("bigint");
+const unknownType = new PrimitiveType("unknown");
+const anyType = new PrimitiveType("any");
+const voidType = new PrimitiveType("void");
+const thisType = new PrimitiveType("this");
+const neverType = new PrimitiveType("never");
+export {
+  PrimitiveType,
+  anyType,
+  bigintType,
+  booleanType,
+  neverType,
+  nullType,
+  numberType,
+  stringType,
+  thisType,
+  undefinedType,
+  unknownType,
+  voidType
+};

package/dist/Property.d.ts

@@ -0,0 +1,18 @@
+import { BasicBuilder } from './BasicBuilder';
+import { DocComment } from './DocComment';
+import { TypeBuilder } from './TypeBuilder';
+import { WellKnownSymbol } from './WellKnownSymbol';
+import { Writer } from './Writer';
+export declare class Property implements BasicBuilder {
+    private name;
+    private type;
+    private isOptional;
+    private isReadonly;
+    private docComment?;
+    constructor(name: string | WellKnownSymbol, type: TypeBuilder);
+    optional(): this;
+    readonly(): this;
+    setDocComment(docComment: DocComment): this;
+    write(writer: Writer): void;
+}
+export declare function property(name: string | WellKnownSymbol, type: TypeBuilder): Property;

package/dist/Property.js

@@ -0,0 +1,75 @@
+"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 Property_exports = {};
+__export(Property_exports, {
+  Property: () => Property,
+  property: () => property
+});
+module.exports = __toCommonJS(Property_exports);
+var import_internals = require("@prisma/internals");
+class Property {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  isOptional = false;
+  isReadonly = false;
+  docComment;
+  optional() {
+    this.isOptional = true;
+    return this;
+  }
+  readonly() {
+    this.isReadonly = true;
+    return this;
+  }
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    if (this.isReadonly) {
+      writer.write("readonly ");
+    }
+    if (typeof this.name === "string") {
+      if ((0, import_internals.isValidJsIdentifier)(this.name)) {
+        writer.write(this.name);
+      } else {
+        writer.write("[").write(JSON.stringify(this.name)).write("]");
+      }
+    } else {
+      writer.write("[").write(this.name).write("]");
+    }
+    if (this.isOptional) {
+      writer.write("?");
+    }
+    writer.write(": ").write(this.type);
+  }
+}
+function property(name, type) {
+  return new Property(name, type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Property,
+  property
+});

package/dist/Property.mjs

@@ -0,0 +1,50 @@
+import { isValidJsIdentifier } from "@prisma/internals";
+class Property {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  isOptional = false;
+  isReadonly = false;
+  docComment;
+  optional() {
+    this.isOptional = true;
+    return this;
+  }
+  readonly() {
+    this.isReadonly = true;
+    return this;
+  }
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    if (this.isReadonly) {
+      writer.write("readonly ");
+    }
+    if (typeof this.name === "string") {
+      if (isValidJsIdentifier(this.name)) {
+        writer.write(this.name);
+      } else {
+        writer.write("[").write(JSON.stringify(this.name)).write("]");
+      }
+    } else {
+      writer.write("[").write(this.name).write("]");
+    }
+    if (this.isOptional) {
+      writer.write("?");
+    }
+    writer.write(": ").write(this.type);
+  }
+}
+function property(name, type) {
+  return new Property(name, type);
+}
+export {
+  Property,
+  property
+};

package/dist/Property.test.d.ts

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

package/dist/Property.test.js

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

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,15 @@
+import { TypeBuilder } from './TypeBuilder';
+import { ValueBuilder } from './ValueBuilder';
+import { Writer } from './Writer';
+export declare class StringLiteralType extends TypeBuilder {
+    readonly content: string;
+    constructor(content: string);
+    write(writer: Writer): void;
+    asValue(): StringLiteralValue;
+}
+export declare class StringLiteralValue extends ValueBuilder {
+    #private;
+    constructor(type: StringLiteralType);
+    write(writer: Writer): void;
+}
+export declare function stringLiteral(content: string): StringLiteralType;

package/dist/StringLiteralType.js

@@ -0,0 +1,58 @@
+"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,
+  StringLiteralValue: () => StringLiteralValue,
+  stringLiteral: () => stringLiteral
+});
+module.exports = __toCommonJS(StringLiteralType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+var import_ValueBuilder = require("./ValueBuilder");
+class StringLiteralType extends import_TypeBuilder.TypeBuilder {
+  constructor(content) {
+    super();
+    this.content = content;
+  }
+  write(writer) {
+    writer.write(JSON.stringify(this.content));
+  }
+  asValue() {
+    return new StringLiteralValue(this);
+  }
+}
+class StringLiteralValue extends import_ValueBuilder.ValueBuilder {
+  #type;
+  constructor(type) {
+    super();
+    this.#type = type;
+  }
+  write(writer) {
+    writer.write(this.#type);
+  }
+}
+function stringLiteral(content) {
+  return new StringLiteralType(content);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StringLiteralType,
+  StringLiteralValue,
+  stringLiteral
+});

package/dist/StringLiteralType.mjs

@@ -0,0 +1,32 @@
+import { TypeBuilder } from "./TypeBuilder";
+import { ValueBuilder } from "./ValueBuilder";
+class StringLiteralType extends TypeBuilder {
+  constructor(content) {
+    super();
+    this.content = content;
+  }
+  write(writer) {
+    writer.write(JSON.stringify(this.content));
+  }
+  asValue() {
+    return new StringLiteralValue(this);
+  }
+}
+class StringLiteralValue extends ValueBuilder {
+  #type;
+  constructor(type) {
+    super();
+    this.#type = type;
+  }
+  write(writer) {
+    writer.write(this.#type);
+  }
+}
+function stringLiteral(content) {
+  return new StringLiteralType(content);
+}
+export {
+  StringLiteralType,
+  StringLiteralValue,
+  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
+});