@prisma/ts-builders 6.6.0-dev.100

package/dist/Writer.js

@@ -0,0 +1,175 @@
+"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 Writer_exports = {};
+__export(Writer_exports, {
+  INDENT_SIZE: () => INDENT_SIZE,
+  Writer: () => Writer
+});
+module.exports = __toCommonJS(Writer_exports);
+const INDENT_SIZE = 2;
+class Writer {
+  constructor(startingIndent = 0, context) {
+    this.context = context;
+    this.currentIndent = startingIndent;
+  }
+  lines = [];
+  currentLine = "";
+  currentIndent = 0;
+  marginSymbol;
+  afterNextNewLineCallback;
+  /**
+   * Adds provided value to the current line. Does not end the line.
+   *
+   * @param value
+   * @returns
+   */
+  write(value) {
+    if (typeof value === "string") {
+      this.currentLine += value;
+    } else {
+      value.write(this);
+    }
+    return this;
+  }
+  /**
+   * Adds several `values` to the current line, separated by `separator`. Both values and separator
+   * can also be `Builder` instances for more advanced formatting.
+   *
+   * @param separator
+   * @param values
+   * @param writeItem allow to customize how individual item is written
+   * @returns
+   */
+  writeJoined(separator, values, writeItem = (item, w) => w.write(item)) {
+    const last = values.length - 1;
+    for (let i = 0; i < values.length; i++) {
+      writeItem(values[i], this);
+      if (i !== last) {
+        this.write(separator);
+      }
+    }
+    return this;
+  }
+  /**
+   * Adds a string to current line, flushes current line and starts a new line.
+   * @param line
+   * @returns
+   */
+  writeLine(line) {
+    return this.write(line).newLine();
+  }
+  /**
+   * Flushes current line and starts a new line. New line starts at previously configured indentation level
+   * @returns
+   */
+  newLine() {
+    this.lines.push(this.indentedCurrentLine());
+    this.currentLine = "";
+    this.marginSymbol = void 0;
+    const afterNextNewLineCallback = this.afterNextNewLineCallback;
+    this.afterNextNewLineCallback = void 0;
+    afterNextNewLineCallback?.();
+    return this;
+  }
+  /**
+   * Increases indentation level by 1, calls provided callback and then decreases indentation again.
+   * Could be used for writing indented blocks of text:
+   *
+   * @example
+   * ```ts
+   * writer
+   *   .writeLine('{')
+   *   .withIndent(() => {
+   *      writer.writeLine('foo: 123');
+   *      writer.writeLine('bar: 456');
+   *   })
+   *   .writeLine('}')
+   * ```
+   * @param callback
+   * @returns
+   */
+  withIndent(callback) {
+    this.indent();
+    callback(this);
+    this.unindent();
+    return this;
+  }
+  /**
+   * Calls provided callback next time when new line is started.
+   * Callback is called after old line have already been flushed and a new
+   * line have been started. Can be used for adding "between the lines" decorations,
+   * such as underlines.
+   *
+   * @param callback
+   * @returns
+   */
+  afterNextNewline(callback) {
+    this.afterNextNewLineCallback = callback;
+    return this;
+  }
+  /**
+   * Increases indentation level of the current line by 1
+   * @returns
+   */
+  indent() {
+    this.currentIndent++;
+    return this;
+  }
+  /**
+   * Decreases indentation level of the current line by 1, if it is possible
+   * @returns
+   */
+  unindent() {
+    if (this.currentIndent > 0) {
+      this.currentIndent--;
+    }
+    return this;
+  }
+  /**
+   * Adds a symbol, that will replace the first character of the current line (including indentation)
+   * when it is flushed. Can be used for adding markers to the line.
+   *
+   * Note: if indentation level of the line is 0, it will replace the first actually printed character
+   * of the line. Use with caution.
+   * @param symbol
+   * @returns
+   */
+  addMarginSymbol(symbol) {
+    this.marginSymbol = symbol;
+    return this;
+  }
+  toString() {
+    return this.lines.concat(this.indentedCurrentLine()).join("\n");
+  }
+  getCurrentLineLength() {
+    return this.currentLine.length;
+  }
+  indentedCurrentLine() {
+    const line = this.currentLine.padStart(this.currentLine.length + INDENT_SIZE * this.currentIndent);
+    if (this.marginSymbol) {
+      return this.marginSymbol + line.slice(1);
+    }
+    return line;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INDENT_SIZE,
+  Writer
+});

package/dist/Writer.mjs

@@ -0,0 +1,150 @@
+const INDENT_SIZE = 2;
+class Writer {
+  constructor(startingIndent = 0, context) {
+    this.context = context;
+    this.currentIndent = startingIndent;
+  }
+  lines = [];
+  currentLine = "";
+  currentIndent = 0;
+  marginSymbol;
+  afterNextNewLineCallback;
+  /**
+   * Adds provided value to the current line. Does not end the line.
+   *
+   * @param value
+   * @returns
+   */
+  write(value) {
+    if (typeof value === "string") {
+      this.currentLine += value;
+    } else {
+      value.write(this);
+    }
+    return this;
+  }
+  /**
+   * Adds several `values` to the current line, separated by `separator`. Both values and separator
+   * can also be `Builder` instances for more advanced formatting.
+   *
+   * @param separator
+   * @param values
+   * @param writeItem allow to customize how individual item is written
+   * @returns
+   */
+  writeJoined(separator, values, writeItem = (item, w) => w.write(item)) {
+    const last = values.length - 1;
+    for (let i = 0; i < values.length; i++) {
+      writeItem(values[i], this);
+      if (i !== last) {
+        this.write(separator);
+      }
+    }
+    return this;
+  }
+  /**
+   * Adds a string to current line, flushes current line and starts a new line.
+   * @param line
+   * @returns
+   */
+  writeLine(line) {
+    return this.write(line).newLine();
+  }
+  /**
+   * Flushes current line and starts a new line. New line starts at previously configured indentation level
+   * @returns
+   */
+  newLine() {
+    this.lines.push(this.indentedCurrentLine());
+    this.currentLine = "";
+    this.marginSymbol = void 0;
+    const afterNextNewLineCallback = this.afterNextNewLineCallback;
+    this.afterNextNewLineCallback = void 0;
+    afterNextNewLineCallback?.();
+    return this;
+  }
+  /**
+   * Increases indentation level by 1, calls provided callback and then decreases indentation again.
+   * Could be used for writing indented blocks of text:
+   *
+   * @example
+   * ```ts
+   * writer
+   *   .writeLine('{')
+   *   .withIndent(() => {
+   *      writer.writeLine('foo: 123');
+   *      writer.writeLine('bar: 456');
+   *   })
+   *   .writeLine('}')
+   * ```
+   * @param callback
+   * @returns
+   */
+  withIndent(callback) {
+    this.indent();
+    callback(this);
+    this.unindent();
+    return this;
+  }
+  /**
+   * Calls provided callback next time when new line is started.
+   * Callback is called after old line have already been flushed and a new
+   * line have been started. Can be used for adding "between the lines" decorations,
+   * such as underlines.
+   *
+   * @param callback
+   * @returns
+   */
+  afterNextNewline(callback) {
+    this.afterNextNewLineCallback = callback;
+    return this;
+  }
+  /**
+   * Increases indentation level of the current line by 1
+   * @returns
+   */
+  indent() {
+    this.currentIndent++;
+    return this;
+  }
+  /**
+   * Decreases indentation level of the current line by 1, if it is possible
+   * @returns
+   */
+  unindent() {
+    if (this.currentIndent > 0) {
+      this.currentIndent--;
+    }
+    return this;
+  }
+  /**
+   * Adds a symbol, that will replace the first character of the current line (including indentation)
+   * when it is flushed. Can be used for adding markers to the line.
+   *
+   * Note: if indentation level of the line is 0, it will replace the first actually printed character
+   * of the line. Use with caution.
+   * @param symbol
+   * @returns
+   */
+  addMarginSymbol(symbol) {
+    this.marginSymbol = symbol;
+    return this;
+  }
+  toString() {
+    return this.lines.concat(this.indentedCurrentLine()).join("\n");
+  }
+  getCurrentLineLength() {
+    return this.currentLine.length;
+  }
+  indentedCurrentLine() {
+    const line = this.currentLine.padStart(this.currentLine.length + INDENT_SIZE * this.currentIndent);
+    if (this.marginSymbol) {
+      return this.marginSymbol + line.slice(1);
+    }
+    return line;
+  }
+}
+export {
+  INDENT_SIZE,
+  Writer
+};

package/dist/Writer.test.d.ts

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

package/dist/Writer.test.js

@@ -0,0 +1,100 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_Writer = require("./Writer");
+(0, import_vitest.test)("write string", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.write("A").write("B").write("C");
+  (0, import_vitest.expect)(writer.toString()).toBe("ABC");
+});
+(0, import_vitest.test)("write builder", () => {
+  const builder = {
+    write(writer2) {
+      writer2.write("hello from builder");
+    }
+  };
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.write(builder);
+  (0, import_vitest.expect)(writer.toString()).toBe("hello from builder");
+});
+(0, import_vitest.test)("newLine", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.newLine();
+  (0, import_vitest.expect)(writer.toString()).toBe("\n");
+});
+(0, import_vitest.test)("writeLine", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.writeLine("A").writeLine("B").writeLine("C");
+  (0, import_vitest.expect)(writer.toString()).toBe("A\nB\nC\n");
+});
+(0, import_vitest.test)("writeJoined with strings", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.writeJoined(", ", ["A", "B", "C"]);
+  (0, import_vitest.expect)(writer.toString()).toBe("A, B, C");
+});
+(0, import_vitest.test)("writeJoined with builder values", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  const builder = {
+    write(writer2) {
+      writer2.write("builder");
+    }
+  };
+  writer.writeJoined(", ", [builder, builder, builder]);
+  (0, import_vitest.expect)(writer.toString()).toBe("builder, builder, builder");
+});
+(0, import_vitest.test)("writeJoined with builder separator", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  const separator = {
+    write(writer2) {
+      writer2.write("|");
+    }
+  };
+  writer.writeJoined(separator, ["A", "B", "C"]);
+  (0, import_vitest.expect)(writer.toString()).toBe("A|B|C");
+});
+(0, import_vitest.test)("writeJoined empty", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.writeJoined(", ", []);
+  (0, import_vitest.expect)(writer.toString()).toBe("");
+});
+(0, import_vitest.test)("indent", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.indent().write("A");
+  (0, import_vitest.expect)(writer.toString()).toBe("  A");
+});
+(0, import_vitest.test)("indent + unindent", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.writeLine("A").indent().writeLine("B").unindent().writeLine("C");
+  (0, import_vitest.expect)(writer.toString()).toBe("A\n  B\nC\n");
+});
+(0, import_vitest.test)("unindent beyond 0", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.unindent().unindent().write("A");
+  (0, import_vitest.expect)(writer.toString()).toBe("A");
+});
+(0, import_vitest.test)("withIndent", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.writeLine("A").withIndent(() => writer.writeLine("B")).writeLine("C");
+  (0, import_vitest.expect)(writer.toString()).toBe("A\n  B\nC\n");
+});
+(0, import_vitest.test)("after next newline callback", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.afterNextNewline(() => {
+    writer.writeLine("---");
+  });
+  writer.writeLine("foo");
+  writer.writeLine("bar");
+  (0, import_vitest.expect)(writer.toString()).toBe("foo\n---\nbar\n");
+});
+(0, import_vitest.test)("margin symbol", () => {
+  const writer = new import_Writer.Writer(0, void 0);
+  writer.writeLine("{").withIndent(() => {
+    writer.addMarginSymbol("+").writeLine("foo").writeLine("bar");
+  }).writeLine("}");
+  (0, import_vitest.expect)(writer.toString()).toMatchInlineSnapshot(`
+    "{
+    + foo
+      bar
+    }
+    "
+  `);
+});

package/dist/Writer.test.mjs

@@ -0,0 +1,99 @@
+import { expect, test } from "vitest";
+import { Writer } from "./Writer";
+test("write string", () => {
+  const writer = new Writer(0, void 0);
+  writer.write("A").write("B").write("C");
+  expect(writer.toString()).toBe("ABC");
+});
+test("write builder", () => {
+  const builder = {
+    write(writer2) {
+      writer2.write("hello from builder");
+    }
+  };
+  const writer = new Writer(0, void 0);
+  writer.write(builder);
+  expect(writer.toString()).toBe("hello from builder");
+});
+test("newLine", () => {
+  const writer = new Writer(0, void 0);
+  writer.newLine();
+  expect(writer.toString()).toBe("\n");
+});
+test("writeLine", () => {
+  const writer = new Writer(0, void 0);
+  writer.writeLine("A").writeLine("B").writeLine("C");
+  expect(writer.toString()).toBe("A\nB\nC\n");
+});
+test("writeJoined with strings", () => {
+  const writer = new Writer(0, void 0);
+  writer.writeJoined(", ", ["A", "B", "C"]);
+  expect(writer.toString()).toBe("A, B, C");
+});
+test("writeJoined with builder values", () => {
+  const writer = new Writer(0, void 0);
+  const builder = {
+    write(writer2) {
+      writer2.write("builder");
+    }
+  };
+  writer.writeJoined(", ", [builder, builder, builder]);
+  expect(writer.toString()).toBe("builder, builder, builder");
+});
+test("writeJoined with builder separator", () => {
+  const writer = new Writer(0, void 0);
+  const separator = {
+    write(writer2) {
+      writer2.write("|");
+    }
+  };
+  writer.writeJoined(separator, ["A", "B", "C"]);
+  expect(writer.toString()).toBe("A|B|C");
+});
+test("writeJoined empty", () => {
+  const writer = new Writer(0, void 0);
+  writer.writeJoined(", ", []);
+  expect(writer.toString()).toBe("");
+});
+test("indent", () => {
+  const writer = new Writer(0, void 0);
+  writer.indent().write("A");
+  expect(writer.toString()).toBe("  A");
+});
+test("indent + unindent", () => {
+  const writer = new Writer(0, void 0);
+  writer.writeLine("A").indent().writeLine("B").unindent().writeLine("C");
+  expect(writer.toString()).toBe("A\n  B\nC\n");
+});
+test("unindent beyond 0", () => {
+  const writer = new Writer(0, void 0);
+  writer.unindent().unindent().write("A");
+  expect(writer.toString()).toBe("A");
+});
+test("withIndent", () => {
+  const writer = new Writer(0, void 0);
+  writer.writeLine("A").withIndent(() => writer.writeLine("B")).writeLine("C");
+  expect(writer.toString()).toBe("A\n  B\nC\n");
+});
+test("after next newline callback", () => {
+  const writer = new Writer(0, void 0);
+  writer.afterNextNewline(() => {
+    writer.writeLine("---");
+  });
+  writer.writeLine("foo");
+  writer.writeLine("bar");
+  expect(writer.toString()).toBe("foo\n---\nbar\n");
+});
+test("margin symbol", () => {
+  const writer = new Writer(0, void 0);
+  writer.writeLine("{").withIndent(() => {
+    writer.addMarginSymbol("+").writeLine("foo").writeLine("bar");
+  }).writeLine("}");
+  expect(writer.toString()).toMatchInlineSnapshot(`
+    "{
+    + foo
+      bar
+    }
+    "
+  `);
+});

package/dist/helpers.d.ts

@@ -0,0 +1,3 @@
+import { NamedType } from './NamedType';
+import { TypeBuilder } from './TypeBuilder';
+export declare function omit(type: TypeBuilder, keyType: TypeBuilder): NamedType;

package/dist/helpers.js

@@ -0,0 +1,31 @@
+"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 helpers_exports = {};
+__export(helpers_exports, {
+  omit: () => omit
+});
+module.exports = __toCommonJS(helpers_exports);
+var import_NamedType = require("./NamedType");
+function omit(type, keyType) {
+  return (0, import_NamedType.namedType)("Omit").addGenericArgument(type).addGenericArgument(keyType);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  omit
+});

package/dist/helpers.mjs

@@ -0,0 +1,7 @@
+import { namedType } from "./NamedType";
+function omit(type, keyType) {
+  return namedType("Omit").addGenericArgument(type).addGenericArgument(keyType);
+}
+export {
+  omit
+};

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export * from './AnyDeclarationBuilder';
+export * from './ArraySpread';
+export * from './ArrayType';
+export * from './BasicBuilder';
+export * from './Class';
+export * from './ConstDeclaration';
+export * from './DocComment';
+export * from './Export';
+export * from './ExportFrom';
+export * from './File';
+export * from './FunctionCall';
+export * from './FunctionType';
+export * from './GenericParameter';
+export * from './helpers';
+export * from './Import';
+export * from './Interface';
+export * from './KeyofType';
+export * from './KeyType';
+export * from './Method';
+export * from './NamedType';
+export * from './NamedValue';
+export * from './NamespaceDeclaration';
+export * from './ObjectType';
+export * from './Parameter';
+export * from './PrimitiveType';
+export * from './Property';
+export * from './stringify';
+export * from './StringLiteralType';
+export * from './TupleType';
+export * from './TypeBuilder';
+export * from './TypeDeclaration';
+export * from './UnionType';
+export * from './ValueBuilder';
+export * from './WellKnownSymbol';
+export * from './Writer';