@prisma/ts-builders 6.6.0-dev.59

package/dist/NamespaceDeclaration.mjs

@@ -0,0 +1,23 @@
+class NamespaceDeclaration {
+  constructor(name) {
+    this.name = name;
+  }
+  items = [];
+  add(declaration) {
+    this.items.push(declaration);
+  }
+  write(writer) {
+    writer.writeLine(`namespace ${this.name} {`).withIndent(() => {
+      for (const item of this.items) {
+        writer.writeLine(item);
+      }
+    }).write("}");
+  }
+}
+function namespace(name) {
+  return new NamespaceDeclaration(name);
+}
+export {
+  NamespaceDeclaration,
+  namespace
+};

package/dist/ObjectType.d.ts

@@ -0,0 +1,18 @@
+import { Method } from './Method';
+import { Property } from './Property';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+type ObjectTypeItem = Method | Property;
+export declare class ObjectType extends TypeBuilder {
+    needsParenthesisWhenIndexed: boolean;
+    private items;
+    private inline;
+    add(item: ObjectTypeItem): this;
+    addMultiple(items: ObjectTypeItem[]): this;
+    formatInline(): this;
+    write(writer: Writer): void;
+    private writeMultiline;
+    private writeInline;
+}
+export declare function objectType(): ObjectType;
+export {};

package/dist/ObjectType.js

@@ -0,0 +1,71 @@
+"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 ObjectType_exports = {};
+__export(ObjectType_exports, {
+  ObjectType: () => ObjectType,
+  objectType: () => objectType
+});
+module.exports = __toCommonJS(ObjectType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class ObjectType extends import_TypeBuilder.TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  items = [];
+  inline = false;
+  add(item) {
+    this.items.push(item);
+    return this;
+  }
+  addMultiple(items) {
+    for (const item of items) {
+      this.add(item);
+    }
+    return this;
+  }
+  formatInline() {
+    this.inline = true;
+    return this;
+  }
+  write(writer) {
+    if (this.items.length === 0) {
+      writer.write("{}");
+    } else if (this.inline) {
+      this.writeInline(writer);
+    } else {
+      this.writeMultiline(writer);
+    }
+  }
+  writeMultiline(writer) {
+    writer.writeLine("{").withIndent(() => {
+      for (const item of this.items) {
+        writer.writeLine(item);
+      }
+    }).write("}");
+  }
+  writeInline(writer) {
+    writer.write("{ ").writeJoined(", ", this.items).write(" }");
+  }
+}
+function objectType() {
+  return new ObjectType();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObjectType,
+  objectType
+});

package/dist/ObjectType.mjs

@@ -0,0 +1,46 @@
+import { TypeBuilder } from "./TypeBuilder";
+class ObjectType extends TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  items = [];
+  inline = false;
+  add(item) {
+    this.items.push(item);
+    return this;
+  }
+  addMultiple(items) {
+    for (const item of items) {
+      this.add(item);
+    }
+    return this;
+  }
+  formatInline() {
+    this.inline = true;
+    return this;
+  }
+  write(writer) {
+    if (this.items.length === 0) {
+      writer.write("{}");
+    } else if (this.inline) {
+      this.writeInline(writer);
+    } else {
+      this.writeMultiline(writer);
+    }
+  }
+  writeMultiline(writer) {
+    writer.writeLine("{").withIndent(() => {
+      for (const item of this.items) {
+        writer.writeLine(item);
+      }
+    }).write("}");
+  }
+  writeInline(writer) {
+    writer.write("{ ").writeJoined(", ", this.items).write(" }");
+  }
+}
+function objectType() {
+  return new ObjectType();
+}
+export {
+  ObjectType,
+  objectType
+};

package/dist/ObjectType.test.d.ts

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

package/dist/ObjectType.test.js

@@ -0,0 +1,32 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_Method = require("./Method");
+var import_NamedType = require("./NamedType");
+var import_ObjectType = require("./ObjectType");
+var import_Property = require("./Property");
+var import_stringify = require("./stringify");
+const A = (0, import_NamedType.namedType)("A");
+(0, import_vitest.test)("empty", () => {
+  const obj = (0, import_ObjectType.objectType)();
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`"{}"`);
+});
+(0, import_vitest.test)("with property", () => {
+  const obj = (0, import_ObjectType.objectType)().add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "{
+      foo: A
+    }"
+  `);
+});
+(0, import_vitest.test)("with method", () => {
+  const obj = (0, import_ObjectType.objectType)().add((0, import_Method.method)("doThing"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "{
+      doThing(): void
+    }"
+  `);
+});
+(0, import_vitest.test)("inline formatting", () => {
+  const obj = (0, import_ObjectType.objectType)().add((0, import_Property.property)("foo", A)).formatInline();
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`"{ foo: A }"`);
+});

package/dist/ObjectType.test.mjs

@@ -0,0 +1,31 @@
+import { expect, test } from "vitest";
+import { method } from "./Method";
+import { namedType } from "./NamedType";
+import { objectType } from "./ObjectType";
+import { property } from "./Property";
+import { stringify } from "./stringify";
+const A = namedType("A");
+test("empty", () => {
+  const obj = objectType();
+  expect(stringify(obj)).toMatchInlineSnapshot(`"{}"`);
+});
+test("with property", () => {
+  const obj = objectType().add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "{
+      foo: A
+    }"
+  `);
+});
+test("with method", () => {
+  const obj = objectType().add(method("doThing"));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "{
+      doThing(): void
+    }"
+  `);
+});
+test("inline formatting", () => {
+  const obj = objectType().add(property("foo", A)).formatInline();
+  expect(stringify(obj)).toMatchInlineSnapshot(`"{ foo: A }"`);
+});

package/dist/Parameter.d.ts

@@ -0,0 +1,12 @@
+import { BasicBuilder } from './BasicBuilder';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class Parameter implements BasicBuilder {
+    private name;
+    private type;
+    private isOptional;
+    constructor(name: string, type: TypeBuilder);
+    optional(): this;
+    write(writer: Writer): void;
+}
+export declare function parameter(name: string, type: TypeBuilder): Parameter;

package/dist/Parameter.js

@@ -0,0 +1,50 @@
+"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 Parameter_exports = {};
+__export(Parameter_exports, {
+  Parameter: () => Parameter,
+  parameter: () => parameter
+});
+module.exports = __toCommonJS(Parameter_exports);
+class Parameter {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  isOptional = false;
+  optional() {
+    this.isOptional = true;
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.isOptional) {
+      writer.write("?");
+    }
+    writer.write(": ").write(this.type);
+  }
+}
+function parameter(name, type) {
+  return new Parameter(name, type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Parameter,
+  parameter
+});

package/dist/Parameter.mjs

@@ -0,0 +1,25 @@
+class Parameter {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  isOptional = false;
+  optional() {
+    this.isOptional = true;
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.isOptional) {
+      writer.write("?");
+    }
+    writer.write(": ").write(this.type);
+  }
+}
+function parameter(name, type) {
+  return new Parameter(name, type);
+}
+export {
+  Parameter,
+  parameter
+};

package/dist/Parameter.test.d.ts

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

package/dist/Parameter.test.js

@@ -0,0 +1,14 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_NamedType = require("./NamedType");
+var import_Parameter = require("./Parameter");
+var import_stringify = require("./stringify");
+const A = (0, import_NamedType.namedType)("A");
+(0, import_vitest.test)("name and type", () => {
+  const param = (0, import_Parameter.parameter)("foo", A);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(param)).toMatchInlineSnapshot(`"foo: A"`);
+});
+(0, import_vitest.test)("optional", () => {
+  const param = (0, import_Parameter.parameter)("foo", A).optional();
+  (0, import_vitest.expect)((0, import_stringify.stringify)(param)).toMatchInlineSnapshot(`"foo?: A"`);
+});

package/dist/Parameter.test.mjs

@@ -0,0 +1,13 @@
+import { expect, test } from "vitest";
+import { namedType } from "./NamedType";
+import { parameter } from "./Parameter";
+import { stringify } from "./stringify";
+const A = namedType("A");
+test("name and type", () => {
+  const param = parameter("foo", A);
+  expect(stringify(param)).toMatchInlineSnapshot(`"foo: A"`);
+});
+test("optional", () => {
+  const param = parameter("foo", A).optional();
+  expect(stringify(param)).toMatchInlineSnapshot(`"foo?: A"`);
+});

package/dist/PrimitiveType.d.ts

@@ -0,0 +1,18 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class PrimitiveType extends TypeBuilder {
+    private name;
+    constructor(name: string);
+    write(writer: Writer): void;
+}
+export declare const stringType: PrimitiveType;
+export declare const numberType: PrimitiveType;
+export declare const booleanType: PrimitiveType;
+export declare const nullType: PrimitiveType;
+export declare const undefinedType: PrimitiveType;
+export declare const bigintType: PrimitiveType;
+export declare const unknownType: PrimitiveType;
+export declare const anyType: PrimitiveType;
+export declare const voidType: PrimitiveType;
+export declare const thisType: PrimitiveType;
+export declare const neverType: PrimitiveType;

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"
+  `);
+});