@prisma/ts-builders 6.6.0-dev.59

package/dist/ExportFrom.d.ts

@@ -0,0 +1,32 @@
+import { BasicBuilder } from './BasicBuilder';
+import { Writer } from './Writer';
+export type ExportFrom = NamespaceExport | BindingsExport | ExportAllFrom;
+export declare class NamespaceExport implements BasicBuilder {
+    private from;
+    private namespace;
+    constructor(from: string, namespace: string);
+    write(writer: Writer<undefined>): void;
+}
+export declare class BindingsExport implements BasicBuilder {
+    private from;
+    private namedExports;
+    constructor(from: string);
+    named(namedExport: string | NamedExport): this;
+    write(writer: Writer<undefined>): void;
+}
+export declare class NamedExport implements BasicBuilder {
+    readonly name: string;
+    private alias;
+    constructor(name: string);
+    as(alias: string): this;
+    write(writer: Writer): void;
+}
+export declare class ExportAllFrom implements BasicBuilder {
+    private from;
+    constructor(from: string);
+    asNamespace(namespace: string): NamespaceExport;
+    named(binding: string | NamedExport): BindingsExport;
+    write(writer: Writer): void;
+}
+export declare function moduleExportFrom(from: string): ExportAllFrom;
+export declare function namedExport(name: string): NamedExport;

package/dist/ExportFrom.js

@@ -0,0 +1,98 @@
+"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 ExportFrom_exports = {};
+__export(ExportFrom_exports, {
+  BindingsExport: () => BindingsExport,
+  ExportAllFrom: () => ExportAllFrom,
+  NamedExport: () => NamedExport,
+  NamespaceExport: () => NamespaceExport,
+  moduleExportFrom: () => moduleExportFrom,
+  namedExport: () => namedExport
+});
+module.exports = __toCommonJS(ExportFrom_exports);
+class NamespaceExport {
+  constructor(from, namespace) {
+    this.from = from;
+    this.namespace = namespace;
+  }
+  write(writer) {
+    writer.write(`export * as ${this.namespace} from '${this.from}'`);
+  }
+}
+class BindingsExport {
+  constructor(from) {
+    this.from = from;
+  }
+  namedExports = [];
+  named(namedExport2) {
+    if (typeof namedExport2 === "string") {
+      namedExport2 = new NamedExport(namedExport2);
+    }
+    this.namedExports.push(namedExport2);
+    return this;
+  }
+  write(writer) {
+    writer.write("export ").write("{ ").writeJoined(", ", this.namedExports).write(" }").write(` from "${this.from}"`);
+  }
+}
+class NamedExport {
+  constructor(name) {
+    this.name = name;
+  }
+  alias;
+  as(alias) {
+    this.alias = alias;
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.alias) {
+      writer.write(" as ").write(this.alias);
+    }
+  }
+}
+class ExportAllFrom {
+  constructor(from) {
+    this.from = from;
+  }
+  asNamespace(namespace) {
+    return new NamespaceExport(this.from, namespace);
+  }
+  named(binding) {
+    return new BindingsExport(this.from).named(binding);
+  }
+  write(writer) {
+    writer.write(`export * from "${this.from}"`);
+  }
+}
+function moduleExportFrom(from) {
+  return new ExportAllFrom(from);
+}
+function namedExport(name) {
+  return new NamedExport(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BindingsExport,
+  ExportAllFrom,
+  NamedExport,
+  NamespaceExport,
+  moduleExportFrom,
+  namedExport
+});

package/dist/ExportFrom.mjs

@@ -0,0 +1,69 @@
+class NamespaceExport {
+  constructor(from, namespace) {
+    this.from = from;
+    this.namespace = namespace;
+  }
+  write(writer) {
+    writer.write(`export * as ${this.namespace} from '${this.from}'`);
+  }
+}
+class BindingsExport {
+  constructor(from) {
+    this.from = from;
+  }
+  namedExports = [];
+  named(namedExport2) {
+    if (typeof namedExport2 === "string") {
+      namedExport2 = new NamedExport(namedExport2);
+    }
+    this.namedExports.push(namedExport2);
+    return this;
+  }
+  write(writer) {
+    writer.write("export ").write("{ ").writeJoined(", ", this.namedExports).write(" }").write(` from "${this.from}"`);
+  }
+}
+class NamedExport {
+  constructor(name) {
+    this.name = name;
+  }
+  alias;
+  as(alias) {
+    this.alias = alias;
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.alias) {
+      writer.write(" as ").write(this.alias);
+    }
+  }
+}
+class ExportAllFrom {
+  constructor(from) {
+    this.from = from;
+  }
+  asNamespace(namespace) {
+    return new NamespaceExport(this.from, namespace);
+  }
+  named(binding) {
+    return new BindingsExport(this.from).named(binding);
+  }
+  write(writer) {
+    writer.write(`export * from "${this.from}"`);
+  }
+}
+function moduleExportFrom(from) {
+  return new ExportAllFrom(from);
+}
+function namedExport(name) {
+  return new NamedExport(name);
+}
+export {
+  BindingsExport,
+  ExportAllFrom,
+  NamedExport,
+  NamespaceExport,
+  moduleExportFrom,
+  namedExport
+};

package/dist/ExportFrom.test.d.ts

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

package/dist/ExportFrom.test.js

@@ -0,0 +1,25 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_ExportFrom = require("./ExportFrom");
+var import_stringify = require("./stringify");
+(0, import_vitest.test)("module name only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_ExportFrom.moduleExportFrom)("someModule"))).toMatchInlineSnapshot(`"export * from "someModule""`);
+});
+(0, import_vitest.test)("namespace", () => {
+  const exportDecl = (0, import_ExportFrom.moduleExportFrom)("myModule").asNamespace("ns");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(exportDecl)).toMatchInlineSnapshot(`"export * as ns from 'myModule'"`);
+});
+(0, import_vitest.test)("named", () => {
+  const exportDecl = (0, import_ExportFrom.moduleExportFrom)("myModule").named("func");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(exportDecl)).toMatchInlineSnapshot(`"export { func } from "myModule""`);
+});
+(0, import_vitest.test)("named with alias", () => {
+  const exportDecl = (0, import_ExportFrom.moduleExportFrom)("myModule").named((0, import_ExportFrom.namedExport)("func").as("myFunc"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(exportDecl)).toMatchInlineSnapshot(`"export { func as myFunc } from "myModule""`);
+});
+(0, import_vitest.test)("multiple named", () => {
+  const exportDecl = (0, import_ExportFrom.moduleExportFrom)("myModule").named("func1").named("func2").named((0, import_ExportFrom.namedExport)("func3").as("aliasedFunc3"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(exportDecl)).toMatchInlineSnapshot(
+    `"export { func1, func2, func3 as aliasedFunc3 } from "myModule""`
+  );
+});

package/dist/ExportFrom.test.mjs

@@ -0,0 +1,24 @@
+import { expect, test } from "vitest";
+import { moduleExportFrom, namedExport } from "./ExportFrom";
+import { stringify } from "./stringify";
+test("module name only", () => {
+  expect(stringify(moduleExportFrom("someModule"))).toMatchInlineSnapshot(`"export * from "someModule""`);
+});
+test("namespace", () => {
+  const exportDecl = moduleExportFrom("myModule").asNamespace("ns");
+  expect(stringify(exportDecl)).toMatchInlineSnapshot(`"export * as ns from 'myModule'"`);
+});
+test("named", () => {
+  const exportDecl = moduleExportFrom("myModule").named("func");
+  expect(stringify(exportDecl)).toMatchInlineSnapshot(`"export { func } from "myModule""`);
+});
+test("named with alias", () => {
+  const exportDecl = moduleExportFrom("myModule").named(namedExport("func").as("myFunc"));
+  expect(stringify(exportDecl)).toMatchInlineSnapshot(`"export { func as myFunc } from "myModule""`);
+});
+test("multiple named", () => {
+  const exportDecl = moduleExportFrom("myModule").named("func1").named("func2").named(namedExport("func3").as("aliasedFunc3"));
+  expect(stringify(exportDecl)).toMatchInlineSnapshot(
+    `"export { func1, func2, func3 as aliasedFunc3 } from "myModule""`
+  );
+});

package/dist/File.d.ts

@@ -0,0 +1,15 @@
+import { AnyDeclarationBuilder } from './AnyDeclarationBuilder';
+import { BasicBuilder } from './BasicBuilder';
+import { Export } from './Export';
+import { ExportFrom } from './ExportFrom';
+import { Import } from './Import';
+import { Writer } from './Writer';
+export type FileItem = AnyDeclarationBuilder | Export<any> | ExportFrom;
+export declare class File implements BasicBuilder {
+    private imports;
+    private declarations;
+    addImport(moduleImport: Import): this;
+    add(declaration: FileItem): void;
+    write(writer: Writer<undefined>): void;
+}
+export declare function file(): File;

package/dist/File.js

@@ -0,0 +1,57 @@
+"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 File_exports = {};
+__export(File_exports, {
+  File: () => File,
+  file: () => file
+});
+module.exports = __toCommonJS(File_exports);
+class File {
+  imports = [];
+  declarations = [];
+  addImport(moduleImport) {
+    this.imports.push(moduleImport);
+    return this;
+  }
+  add(declaration) {
+    this.declarations.push(declaration);
+  }
+  write(writer) {
+    for (const moduleImport of this.imports) {
+      writer.writeLine(moduleImport);
+    }
+    if (this.imports.length > 0) {
+      writer.newLine();
+    }
+    for (const [i, declaration] of this.declarations.entries()) {
+      writer.writeLine(declaration);
+      if (i < this.declarations.length - 1) {
+        writer.newLine();
+      }
+    }
+  }
+}
+function file() {
+  return new File();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  File,
+  file
+});

package/dist/File.mjs

@@ -0,0 +1,32 @@
+class File {
+  imports = [];
+  declarations = [];
+  addImport(moduleImport) {
+    this.imports.push(moduleImport);
+    return this;
+  }
+  add(declaration) {
+    this.declarations.push(declaration);
+  }
+  write(writer) {
+    for (const moduleImport of this.imports) {
+      writer.writeLine(moduleImport);
+    }
+    if (this.imports.length > 0) {
+      writer.newLine();
+    }
+    for (const [i, declaration] of this.declarations.entries()) {
+      writer.writeLine(declaration);
+      if (i < this.declarations.length - 1) {
+        writer.newLine();
+      }
+    }
+  }
+}
+function file() {
+  return new File();
+}
+export {
+  File,
+  file
+};

package/dist/FunctionType.d.ts

@@ -0,0 +1,17 @@
+import { GenericParameter } from './GenericParameter';
+import { Parameter } from './Parameter';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class FunctionType extends TypeBuilder {
+    needsParenthesisWhenIndexed: boolean;
+    needsParenthesisInKeyof: boolean;
+    needsParenthesisInUnion: boolean;
+    private returnType;
+    private parameters;
+    private genericParameters;
+    setReturnType(returnType: TypeBuilder): this;
+    addParameter(param: Parameter): this;
+    addGenericParameter(param: GenericParameter): this;
+    write(writer: Writer): void;
+}
+export declare function functionType(): FunctionType;

package/dist/FunctionType.js

@@ -0,0 +1,60 @@
+"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 FunctionType_exports = {};
+__export(FunctionType_exports, {
+  FunctionType: () => FunctionType,
+  functionType: () => functionType
+});
+module.exports = __toCommonJS(FunctionType_exports);
+var import_PrimitiveType = require("./PrimitiveType");
+var import_TypeBuilder = require("./TypeBuilder");
+class FunctionType extends import_TypeBuilder.TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  needsParenthesisInKeyof = true;
+  needsParenthesisInUnion = true;
+  returnType = import_PrimitiveType.voidType;
+  parameters = [];
+  genericParameters = [];
+  setReturnType(returnType) {
+    this.returnType = returnType;
+    return this;
+  }
+  addParameter(param) {
+    this.parameters.push(param);
+    return this;
+  }
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  write(writer) {
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write("(").writeJoined(", ", this.parameters).write(") => ").write(this.returnType);
+  }
+}
+function functionType() {
+  return new FunctionType();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FunctionType,
+  functionType
+});

package/dist/FunctionType.mjs

@@ -0,0 +1,35 @@
+import { voidType } from "./PrimitiveType";
+import { TypeBuilder } from "./TypeBuilder";
+class FunctionType extends TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  needsParenthesisInKeyof = true;
+  needsParenthesisInUnion = true;
+  returnType = voidType;
+  parameters = [];
+  genericParameters = [];
+  setReturnType(returnType) {
+    this.returnType = returnType;
+    return this;
+  }
+  addParameter(param) {
+    this.parameters.push(param);
+    return this;
+  }
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  write(writer) {
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write("(").writeJoined(", ", this.parameters).write(") => ").write(this.returnType);
+  }
+}
+function functionType() {
+  return new FunctionType();
+}
+export {
+  FunctionType,
+  functionType
+};

package/dist/FunctionType.test.d.ts

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

package/dist/FunctionType.test.js

@@ -0,0 +1,32 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_FunctionType = require("./FunctionType");
+var import_GenericParameter = require("./GenericParameter");
+var import_NamedType = require("./NamedType");
+var import_Parameter = require("./Parameter");
+var import_stringify = require("./stringify");
+const A = (0, import_NamedType.namedType)("A");
+const B = (0, import_NamedType.namedType)("B");
+(0, import_vitest.test)("basic", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_FunctionType.functionType)())).toMatchInlineSnapshot(`"() => void"`);
+});
+(0, import_vitest.test)("with return type", () => {
+  const func = (0, import_FunctionType.functionType)().setReturnType(A);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(func)).toMatchInlineSnapshot(`"() => A"`);
+});
+(0, import_vitest.test)("with parameter", () => {
+  const func = (0, import_FunctionType.functionType)().addParameter((0, import_Parameter.parameter)("param", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(func)).toMatchInlineSnapshot(`"(param: A) => void"`);
+});
+(0, import_vitest.test)("with multiple parameters", () => {
+  const func = (0, import_FunctionType.functionType)().addParameter((0, import_Parameter.parameter)("param1", A)).addParameter((0, import_Parameter.parameter)("param2", B));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(func)).toMatchInlineSnapshot(`"(param1: A, param2: B) => void"`);
+});
+(0, import_vitest.test)("with generic parameter", () => {
+  const func = (0, import_FunctionType.functionType)().addGenericParameter((0, import_GenericParameter.genericParameter)("T"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(func)).toMatchInlineSnapshot(`"<T>() => void"`);
+});
+(0, import_vitest.test)("with multiple generic parameters", () => {
+  const func = (0, import_FunctionType.functionType)().addGenericParameter((0, import_GenericParameter.genericParameter)("T")).addGenericParameter((0, import_GenericParameter.genericParameter)("U"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(func)).toMatchInlineSnapshot(`"<T, U>() => void"`);
+});

package/dist/FunctionType.test.mjs

@@ -0,0 +1,31 @@
+import { expect, test } from "vitest";
+import { functionType } from "./FunctionType";
+import { genericParameter } from "./GenericParameter";
+import { namedType } from "./NamedType";
+import { parameter } from "./Parameter";
+import { stringify } from "./stringify";
+const A = namedType("A");
+const B = namedType("B");
+test("basic", () => {
+  expect(stringify(functionType())).toMatchInlineSnapshot(`"() => void"`);
+});
+test("with return type", () => {
+  const func = functionType().setReturnType(A);
+  expect(stringify(func)).toMatchInlineSnapshot(`"() => A"`);
+});
+test("with parameter", () => {
+  const func = functionType().addParameter(parameter("param", A));
+  expect(stringify(func)).toMatchInlineSnapshot(`"(param: A) => void"`);
+});
+test("with multiple parameters", () => {
+  const func = functionType().addParameter(parameter("param1", A)).addParameter(parameter("param2", B));
+  expect(stringify(func)).toMatchInlineSnapshot(`"(param1: A, param2: B) => void"`);
+});
+test("with generic parameter", () => {
+  const func = functionType().addGenericParameter(genericParameter("T"));
+  expect(stringify(func)).toMatchInlineSnapshot(`"<T>() => void"`);
+});
+test("with multiple generic parameters", () => {
+  const func = functionType().addGenericParameter(genericParameter("T")).addGenericParameter(genericParameter("U"));
+  expect(stringify(func)).toMatchInlineSnapshot(`"<T, U>() => void"`);
+});

package/dist/GenericParameter.d.ts

@@ -0,0 +1,15 @@
+import { BasicBuilder } from './BasicBuilder';
+import { NamedType } from './NamedType';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class GenericParameter implements BasicBuilder {
+    private name;
+    private extendedType?;
+    private defaultType?;
+    constructor(name: string);
+    extends(type: TypeBuilder): this;
+    default(type: TypeBuilder): this;
+    toArgument(): NamedType;
+    write(writer: Writer): void;
+}
+export declare function genericParameter(name: string): GenericParameter;

package/dist/GenericParameter.js

@@ -0,0 +1,60 @@
+"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 GenericParameter_exports = {};
+__export(GenericParameter_exports, {
+  GenericParameter: () => GenericParameter,
+  genericParameter: () => genericParameter
+});
+module.exports = __toCommonJS(GenericParameter_exports);
+var import_NamedType = require("./NamedType");
+class GenericParameter {
+  constructor(name) {
+    this.name = name;
+  }
+  extendedType;
+  defaultType;
+  extends(type) {
+    this.extendedType = type;
+    return this;
+  }
+  default(type) {
+    this.defaultType = type;
+    return this;
+  }
+  toArgument() {
+    return new import_NamedType.NamedType(this.name);
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.extendedType) {
+      writer.write(" extends ").write(this.extendedType);
+    }
+    if (this.defaultType) {
+      writer.write(" = ").write(this.defaultType);
+    }
+  }
+}
+function genericParameter(name) {
+  return new GenericParameter(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenericParameter,
+  genericParameter
+});

package/dist/GenericParameter.mjs

@@ -0,0 +1,35 @@
+import { NamedType } from "./NamedType";
+class GenericParameter {
+  constructor(name) {
+    this.name = name;
+  }
+  extendedType;
+  defaultType;
+  extends(type) {
+    this.extendedType = type;
+    return this;
+  }
+  default(type) {
+    this.defaultType = type;
+    return this;
+  }
+  toArgument() {
+    return new NamedType(this.name);
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.extendedType) {
+      writer.write(" extends ").write(this.extendedType);
+    }
+    if (this.defaultType) {
+      writer.write(" = ").write(this.defaultType);
+    }
+  }
+}
+function genericParameter(name) {
+  return new GenericParameter(name);
+}
+export {
+  GenericParameter,
+  genericParameter
+};

package/dist/GenericParameter.test.d.ts

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