@prisma/ts-builders 6.6.0-dev.100

package/dist/NamedType.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 NamedType_exports = {};
+__export(NamedType_exports, {
+  NamedType: () => NamedType,
+  namedType: () => namedType
+});
+module.exports = __toCommonJS(NamedType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class NamedType extends import_TypeBuilder.TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  genericArguments = [];
+  addGenericArgument(type) {
+    this.genericArguments.push(type);
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.genericArguments.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericArguments).write(">");
+    }
+  }
+}
+function namedType(name) {
+  return new NamedType(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamedType,
+  namedType
+});

package/dist/NamedType.mjs

@@ -0,0 +1,25 @@
+import { TypeBuilder } from "./TypeBuilder";
+class NamedType extends TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  genericArguments = [];
+  addGenericArgument(type) {
+    this.genericArguments.push(type);
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.genericArguments.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericArguments).write(">");
+    }
+  }
+}
+function namedType(name) {
+  return new NamedType(name);
+}
+export {
+  NamedType,
+  namedType
+};

package/dist/NamedType.test.d.ts

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

package/dist/NamedType.test.js

@@ -0,0 +1,15 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+(0, import_vitest.test)("name only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_NamedType.namedType)("MyType"))).toMatchInlineSnapshot(`"MyType"`);
+});
+(0, import_vitest.test)("with generic argument", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_NamedType.namedType)("MyType").addGenericArgument((0, import_NamedType.namedType)("Foo")))).toMatchInlineSnapshot(`"MyType<Foo>"`);
+});
+(0, import_vitest.test)("with multiple generic arguments", () => {
+  (0, import_vitest.expect)(
+    (0, import_stringify.stringify)((0, import_NamedType.namedType)("MyType").addGenericArgument((0, import_NamedType.namedType)("Foo")).addGenericArgument((0, import_NamedType.namedType)("Bar")))
+  ).toMatchInlineSnapshot(`"MyType<Foo, Bar>"`);
+});

package/dist/NamedType.test.mjs

@@ -0,0 +1,14 @@
+import { expect, test } from "vitest";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+test("name only", () => {
+  expect(stringify(namedType("MyType"))).toMatchInlineSnapshot(`"MyType"`);
+});
+test("with generic argument", () => {
+  expect(stringify(namedType("MyType").addGenericArgument(namedType("Foo")))).toMatchInlineSnapshot(`"MyType<Foo>"`);
+});
+test("with multiple generic arguments", () => {
+  expect(
+    stringify(namedType("MyType").addGenericArgument(namedType("Foo")).addGenericArgument(namedType("Bar")))
+  ).toMatchInlineSnapshot(`"MyType<Foo, Bar>"`);
+});

package/dist/NamedValue.d.ts

@@ -0,0 +1,8 @@
+import { ValueBuilder } from './ValueBuilder';
+import { Writer } from './Writer';
+export declare class NamedValue extends ValueBuilder {
+    #private;
+    constructor(name: string);
+    write(writer: Writer): void;
+}
+export declare function namedValue(name: string): NamedValue;

package/dist/NamedValue.js

@@ -0,0 +1,43 @@
+"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 NamedValue_exports = {};
+__export(NamedValue_exports, {
+  NamedValue: () => NamedValue,
+  namedValue: () => namedValue
+});
+module.exports = __toCommonJS(NamedValue_exports);
+var import_ValueBuilder = require("./ValueBuilder");
+class NamedValue extends import_ValueBuilder.ValueBuilder {
+  #name;
+  constructor(name) {
+    super();
+    this.#name = name;
+  }
+  write(writer) {
+    writer.write(this.#name);
+  }
+}
+function namedValue(name) {
+  return new NamedValue(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamedValue,
+  namedValue
+});

package/dist/NamedValue.mjs

@@ -0,0 +1,18 @@
+import { ValueBuilder } from "./ValueBuilder";
+class NamedValue extends ValueBuilder {
+  #name;
+  constructor(name) {
+    super();
+    this.#name = name;
+  }
+  write(writer) {
+    writer.write(this.#name);
+  }
+}
+function namedValue(name) {
+  return new NamedValue(name);
+}
+export {
+  NamedValue,
+  namedValue
+};

package/dist/NamespaceDeclaration.d.ts

@@ -0,0 +1,13 @@
+import { AnyDeclarationBuilder } from './AnyDeclarationBuilder';
+import { BasicBuilder } from './BasicBuilder';
+import { Export } from './Export';
+import { Writer } from './Writer';
+export type NamespaceItem = AnyDeclarationBuilder | Export<AnyDeclarationBuilder>;
+export declare class NamespaceDeclaration implements BasicBuilder {
+    readonly name: string;
+    private items;
+    constructor(name: string);
+    add(declaration: NamespaceItem): void;
+    write(writer: Writer<undefined>): void;
+}
+export declare function namespace(name: string): NamespaceDeclaration;

package/dist/NamespaceDeclaration.js

@@ -0,0 +1,48 @@
+"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 NamespaceDeclaration_exports = {};
+__export(NamespaceDeclaration_exports, {
+  NamespaceDeclaration: () => NamespaceDeclaration,
+  namespace: () => namespace
+});
+module.exports = __toCommonJS(NamespaceDeclaration_exports);
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamespaceDeclaration,
+  namespace
+});

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;