@forklaunch/internal 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 forklaunch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.d.mts

@@ -0,0 +1,73 @@
+import { AnySchemaValidator, IdiomaticSchema, Schema } from '@forklaunch/validator';
+import { TypeboxSchemaValidator } from '@forklaunch/validator/typebox';
+import { ZodSchemaValidator } from '@forklaunch/validator/zod';
+import { InstanceTypeRecord } from '@forklaunch/common';
+import { EntityManager } from '@mikro-orm/core';
+
+declare class IdentityRequestMapper<T, SchemaValidator extends AnySchemaValidator> {
+    dto: T;
+    _Entity: T;
+    deserializeDtoToEntity(schemaValidator: SchemaValidator, dto: T): T;
+}
+declare class IdentityResponseMapper<T, SchemaValidator extends AnySchemaValidator> {
+    dto: T;
+    _Entity: T;
+    serializeEntityToDto(schemaValidator: SchemaValidator, entity: T): T;
+}
+
+declare function testSchemaEquality<Schematic>(): <Z extends IdiomaticSchema<ZodSchemaValidator>, T extends IdiomaticSchema<TypeboxSchemaValidator>>(zodSchema: Z, typeBoxSchema: T, testData: Schematic extends Schema<Z, ZodSchemaValidator> ? Schema<Z, ZodSchemaValidator> extends Schematic ? Schematic extends Schema<T, TypeboxSchemaValidator> ? Schema<T, TypeboxSchemaValidator> extends Schematic ? Schematic : {
+    _success: never;
+} & Schematic : {
+    _success: never;
+} & Schematic : {
+    _success: never;
+} & Schematic : {
+    _success: never;
+} & Schematic) => EqualityWithoutFunction<T, Z>;
+type InjectiveWithoutFunction<O, T> = {
+    [K in keyof O]: K extends keyof T ? O[K] extends object ? T[K] extends object ? InjectiveWithoutFunction<O[K], T[K]> : false : O[K] extends (...args: never[]) => unknown ? T[K] extends (...args: never[]) => unknown ? true : false : O[K] extends T[K] ? T[K] extends O[K] ? true : false : false : false;
+} extends infer R ? R extends {
+    [K in keyof R]: true;
+} ? true : false : false;
+type EqualityWithoutFunction<T extends IdiomaticSchema<TypeboxSchemaValidator>, Z extends IdiomaticSchema<ZodSchemaValidator>> = Schema<T, TypeboxSchemaValidator> extends infer TypeboxSchema ? Schema<Z, ZodSchemaValidator> extends infer ZodSchema ? InjectiveWithoutFunction<TypeboxSchema, ZodSchema> extends InjectiveWithoutFunction<ZodSchema, TypeboxSchema> ? true : false : false : false;
+declare enum DummyEnum {
+    A = "A",
+    B = "B"
+}
+
+type AllAfterFirstParameters<T> = T extends (first: never, ...args: infer U) => unknown ? U : never[];
+type InternalDtoMapper<SchemaValidator extends AnySchemaValidator, DtoMapper extends Record<string, {
+    dto: unknown;
+    _Entity: unknown;
+    serializeEntityToDto: unknown;
+} | {
+    dto: unknown;
+    _Entity: unknown;
+    deserializeDtoToEntity: unknown;
+}>, Entities extends Record<keyof DtoMapper, unknown>, Dto extends Record<keyof DtoMapper, unknown>> = {
+    [K in keyof DtoMapper]: DtoMapper[K] extends {
+        dto: unknown;
+        _Entity: unknown;
+        serializeEntityToDto: unknown;
+    } ? {
+        serializeEntityToDto: (schemaValidator: SchemaValidator, entity: Entities[K], ...additionalArgs: AllAfterFirstParameters<DtoMapper[K]['serializeEntityToDto']>) => Promise<Dto[K]>;
+    } : DtoMapper[K] extends {
+        dto: unknown;
+        _Entity: unknown;
+        deserializeDtoToEntity: unknown;
+    } ? {
+        deserializeDtoToEntity: (schemaValidator: SchemaValidator, dto: Dto[K], em?: EntityManager, ...additionalArgs: AllAfterFirstParameters<DtoMapper[K]['deserializeDtoToEntity']>) => Promise<Entities[K]>;
+    } : never;
+};
+
+declare function transformIntoInternalDtoMapper<SchemaValidator extends AnySchemaValidator, DtoMapper extends Record<string, new (schemaValidator: SchemaValidator) => {
+    dto: unknown;
+    _Entity: unknown;
+    serializeEntityToDto: unknown;
+} | {
+    dto: unknown;
+    _Entity: unknown;
+    deserializeDtoToEntity: unknown;
+}>, Entities extends Record<keyof DtoMapper, unknown>, Dto extends Record<keyof DtoMapper, unknown>>(mappers: DtoMapper, schemaValidator: SchemaValidator): InternalDtoMapper<SchemaValidator, InstanceTypeRecord<DtoMapper>, Entities, Dto>;
+
+export { DummyEnum, IdentityRequestMapper, IdentityResponseMapper, type InternalDtoMapper, testSchemaEquality, transformIntoInternalDtoMapper };

package/lib/index.d.ts

@@ -0,0 +1,73 @@
+import { AnySchemaValidator, IdiomaticSchema, Schema } from '@forklaunch/validator';
+import { TypeboxSchemaValidator } from '@forklaunch/validator/typebox';
+import { ZodSchemaValidator } from '@forklaunch/validator/zod';
+import { InstanceTypeRecord } from '@forklaunch/common';
+import { EntityManager } from '@mikro-orm/core';
+
+declare class IdentityRequestMapper<T, SchemaValidator extends AnySchemaValidator> {
+    dto: T;
+    _Entity: T;
+    deserializeDtoToEntity(schemaValidator: SchemaValidator, dto: T): T;
+}
+declare class IdentityResponseMapper<T, SchemaValidator extends AnySchemaValidator> {
+    dto: T;
+    _Entity: T;
+    serializeEntityToDto(schemaValidator: SchemaValidator, entity: T): T;
+}
+
+declare function testSchemaEquality<Schematic>(): <Z extends IdiomaticSchema<ZodSchemaValidator>, T extends IdiomaticSchema<TypeboxSchemaValidator>>(zodSchema: Z, typeBoxSchema: T, testData: Schematic extends Schema<Z, ZodSchemaValidator> ? Schema<Z, ZodSchemaValidator> extends Schematic ? Schematic extends Schema<T, TypeboxSchemaValidator> ? Schema<T, TypeboxSchemaValidator> extends Schematic ? Schematic : {
+    _success: never;
+} & Schematic : {
+    _success: never;
+} & Schematic : {
+    _success: never;
+} & Schematic : {
+    _success: never;
+} & Schematic) => EqualityWithoutFunction<T, Z>;
+type InjectiveWithoutFunction<O, T> = {
+    [K in keyof O]: K extends keyof T ? O[K] extends object ? T[K] extends object ? InjectiveWithoutFunction<O[K], T[K]> : false : O[K] extends (...args: never[]) => unknown ? T[K] extends (...args: never[]) => unknown ? true : false : O[K] extends T[K] ? T[K] extends O[K] ? true : false : false : false;
+} extends infer R ? R extends {
+    [K in keyof R]: true;
+} ? true : false : false;
+type EqualityWithoutFunction<T extends IdiomaticSchema<TypeboxSchemaValidator>, Z extends IdiomaticSchema<ZodSchemaValidator>> = Schema<T, TypeboxSchemaValidator> extends infer TypeboxSchema ? Schema<Z, ZodSchemaValidator> extends infer ZodSchema ? InjectiveWithoutFunction<TypeboxSchema, ZodSchema> extends InjectiveWithoutFunction<ZodSchema, TypeboxSchema> ? true : false : false : false;
+declare enum DummyEnum {
+    A = "A",
+    B = "B"
+}
+
+type AllAfterFirstParameters<T> = T extends (first: never, ...args: infer U) => unknown ? U : never[];
+type InternalDtoMapper<SchemaValidator extends AnySchemaValidator, DtoMapper extends Record<string, {
+    dto: unknown;
+    _Entity: unknown;
+    serializeEntityToDto: unknown;
+} | {
+    dto: unknown;
+    _Entity: unknown;
+    deserializeDtoToEntity: unknown;
+}>, Entities extends Record<keyof DtoMapper, unknown>, Dto extends Record<keyof DtoMapper, unknown>> = {
+    [K in keyof DtoMapper]: DtoMapper[K] extends {
+        dto: unknown;
+        _Entity: unknown;
+        serializeEntityToDto: unknown;
+    } ? {
+        serializeEntityToDto: (schemaValidator: SchemaValidator, entity: Entities[K], ...additionalArgs: AllAfterFirstParameters<DtoMapper[K]['serializeEntityToDto']>) => Promise<Dto[K]>;
+    } : DtoMapper[K] extends {
+        dto: unknown;
+        _Entity: unknown;
+        deserializeDtoToEntity: unknown;
+    } ? {
+        deserializeDtoToEntity: (schemaValidator: SchemaValidator, dto: Dto[K], em?: EntityManager, ...additionalArgs: AllAfterFirstParameters<DtoMapper[K]['deserializeDtoToEntity']>) => Promise<Entities[K]>;
+    } : never;
+};
+
+declare function transformIntoInternalDtoMapper<SchemaValidator extends AnySchemaValidator, DtoMapper extends Record<string, new (schemaValidator: SchemaValidator) => {
+    dto: unknown;
+    _Entity: unknown;
+    serializeEntityToDto: unknown;
+} | {
+    dto: unknown;
+    _Entity: unknown;
+    deserializeDtoToEntity: unknown;
+}>, Entities extends Record<keyof DtoMapper, unknown>, Dto extends Record<keyof DtoMapper, unknown>>(mappers: DtoMapper, schemaValidator: SchemaValidator): InternalDtoMapper<SchemaValidator, InstanceTypeRecord<DtoMapper>, Entities, Dto>;
+
+export { DummyEnum, IdentityRequestMapper, IdentityResponseMapper, type InternalDtoMapper, testSchemaEquality, transformIntoInternalDtoMapper };

package/lib/index.js

@@ -0,0 +1,85 @@
+"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);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  DummyEnum: () => DummyEnum,
+  IdentityRequestMapper: () => IdentityRequestMapper,
+  IdentityResponseMapper: () => IdentityResponseMapper,
+  testSchemaEquality: () => testSchemaEquality,
+  transformIntoInternalDtoMapper: () => transformIntoInternalDtoMapper
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/identityMappers.ts
+var IdentityRequestMapper = class {
+  dto;
+  _Entity;
+  deserializeDtoToEntity(schemaValidator, dto) {
+    return dto;
+  }
+};
+var IdentityResponseMapper = class {
+  dto;
+  _Entity;
+  serializeEntityToDto(schemaValidator, entity) {
+    return entity;
+  }
+};
+
+// src/schemaEquality.ts
+var import_common = require("@forklaunch/common");
+var import_typebox = require("@forklaunch/validator/typebox");
+var import_zod = require("@forklaunch/validator/zod");
+function testSchemaEquality() {
+  return (zodSchema, typeBoxSchema, testData) => {
+    const zodParseResult = (0, import_zod.parse)(zodSchema, testData);
+    const typeboxParseResult = (0, import_typebox.parse)(typeBoxSchema, testData);
+    const isEqual = (0, import_common.safeStringify)(
+      zodParseResult.ok ? (0, import_common.sortObjectKeys)(zodParseResult.value) : "-1"
+    ) === (0, import_common.safeStringify)(
+      typeboxParseResult.ok ? (0, import_common.sortObjectKeys)(typeboxParseResult.value) : "1"
+    );
+    return isEqual;
+  };
+}
+var DummyEnum = /* @__PURE__ */ ((DummyEnum2) => {
+  DummyEnum2["A"] = "A";
+  DummyEnum2["B"] = "B";
+  return DummyEnum2;
+})(DummyEnum || {});
+
+// src/transformIntoInternalDtoMapper.ts
+function transformIntoInternalDtoMapper(mappers, schemaValidator) {
+  return Object.fromEntries(
+    Object.entries(mappers).map(([key, value]) => [
+      key,
+      new value(schemaValidator)
+    ])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DummyEnum,
+  IdentityRequestMapper,
+  IdentityResponseMapper,
+  testSchemaEquality,
+  transformIntoInternalDtoMapper
+});

package/lib/index.mjs

@@ -0,0 +1,58 @@
+// src/identityMappers.ts
+var IdentityRequestMapper = class {
+  dto;
+  _Entity;
+  deserializeDtoToEntity(schemaValidator, dto) {
+    return dto;
+  }
+};
+var IdentityResponseMapper = class {
+  dto;
+  _Entity;
+  serializeEntityToDto(schemaValidator, entity) {
+    return entity;
+  }
+};
+
+// src/schemaEquality.ts
+import { safeStringify, sortObjectKeys } from "@forklaunch/common";
+import {
+  parse as typeboxParse
+} from "@forklaunch/validator/typebox";
+import {
+  parse as zodParse
+} from "@forklaunch/validator/zod";
+function testSchemaEquality() {
+  return (zodSchema, typeBoxSchema, testData) => {
+    const zodParseResult = zodParse(zodSchema, testData);
+    const typeboxParseResult = typeboxParse(typeBoxSchema, testData);
+    const isEqual = safeStringify(
+      zodParseResult.ok ? sortObjectKeys(zodParseResult.value) : "-1"
+    ) === safeStringify(
+      typeboxParseResult.ok ? sortObjectKeys(typeboxParseResult.value) : "1"
+    );
+    return isEqual;
+  };
+}
+var DummyEnum = /* @__PURE__ */ ((DummyEnum2) => {
+  DummyEnum2["A"] = "A";
+  DummyEnum2["B"] = "B";
+  return DummyEnum2;
+})(DummyEnum || {});
+
+// src/transformIntoInternalDtoMapper.ts
+function transformIntoInternalDtoMapper(mappers, schemaValidator) {
+  return Object.fromEntries(
+    Object.entries(mappers).map(([key, value]) => [
+      key,
+      new value(schemaValidator)
+    ])
+  );
+}
+export {
+  DummyEnum,
+  IdentityRequestMapper,
+  IdentityResponseMapper,
+  testSchemaEquality,
+  transformIntoInternalDtoMapper
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@forklaunch/internal",
+  "version": "0.0.1",
+  "description": "Internal package for utilities and other internal code.",
+  "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
+  "bugs": {
+    "url": "https://github.com/forklaunch/forklaunch-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forklaunch/forklaunch-js.git"
+  },
+  "license": "MIT",
+  "author": "Rohin Bhargava",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
+  "types": "lib/index.d.ts",
+  "directories": {
+    "test": "__test__"
+  },
+  "files": [
+    "lib/**"
+  ],
+  "dependencies": {
+    "@mikro-orm/core": "^6.4.16",
+    "@forklaunch/common": "0.3.13",
+    "@forklaunch/validator": "0.6.15"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@types/node": "^24.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20250619.1",
+    "depcheck": "^1.4.7",
+    "eslint": "^9.29.0",
+    "globals": "^16.2.0",
+    "tsup": "^8.5.0",
+    "typedoc": "^0.28.5",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsgo --noEmit && tsup index.ts --format cjs,esm --no-splitting --tsconfig tsconfig.json --outDir lib --dts --clean",
+    "check": "depcheck",
+    "clean": "rm -rf lib pnpm.lock.yaml node_modules",
+    "docs": "typedoc --out docs *",
+    "format": "prettier --ignore-path=.prettierignore --config .prettierrc '**/*.{ts,tsx,json}' --write",
+    "lint": "eslint . -c eslint.config.mjs",
+    "lint:fix": "eslint . -c eslint.config.mjs --fix",
+    "publish:package": "./publish-package.bash",
+    "test": "vitest --passWithNoTests"
+  }
+}