@forklaunch/implementation-iam-base 0.2.3 → 0.3.1

package/lib/services/index.mjs

@@ -0,0 +1,652 @@
+// services/organization.service.ts
+import {
+  evaluateTelemetryOptions
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper
+} from "@forklaunch/core/mappers";
+var BaseOrganizationService = class {
+  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  async createOrganization(organizationDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating organization",
+        organizationDto
+      );
+    }
+    const organization = await this.#mappers.CreateOrganizationDtoMapper.deserializeDtoToEntity(
+      organizationDto,
+      em ?? this.em
+    );
+    if (em) {
+      await em.persist(organization);
+    } else {
+      await this.em.persistAndFlush(organization);
+    }
+    return this.#mappers.OrganizationDtoMapper.serializeEntityToDto(
+      organization
+    );
+  }
+  async getOrganization(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting organization", idDto);
+    }
+    const organization = await (em ?? this.em).findOneOrFail(
+      "Organization",
+      idDto
+    );
+    return this.#mappers.OrganizationDtoMapper.serializeEntityToDto(
+      organization
+    );
+  }
+  async updateOrganization(organizationDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Updating organization",
+        organizationDto
+      );
+    }
+    const updatedOrganization = await this.#mappers.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
+      organizationDto,
+      em ?? this.em
+    );
+    if (em) {
+      await em.persist(updatedOrganization);
+    } else {
+      await this.em.persistAndFlush(updatedOrganization);
+    }
+    return this.#mappers.OrganizationDtoMapper.serializeEntityToDto(
+      updatedOrganization
+    );
+  }
+  async deleteOrganization(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting organization", idDto);
+    }
+    if (em) {
+      await em.nativeDelete("Organization", idDto);
+    } else {
+      await this.em.nativeDelete("Organization", idDto);
+    }
+  }
+};
+
+// services/permission.service.ts
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions2
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper as transformIntoInternalDtoMapper2
+} from "@forklaunch/core/mappers";
+var BasePermissionService = class {
+  constructor(em, roleServiceFactory, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.roleServiceFactory = roleServiceFactory;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.#mappers = transformIntoInternalDtoMapper2(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions2(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  // start: global helper functions
+  async updateRolesWithPermissions(roles, permissions) {
+    return Promise.all(
+      roles.map(async (role) => {
+        permissions.forEach((permission) => role.permissions.add(permission));
+        return role;
+      })
+    );
+  }
+  async removePermissionsFromRoles(roles, permissions) {
+    return Promise.all(
+      roles.map(async (role) => {
+        permissions.forEach(
+          (permission) => role.permissions.remove(permission)
+        );
+        return role;
+      })
+    );
+  }
+  async getBatchRoles(roleIds, em) {
+    return roleIds ? await Promise.all(
+      (await this.roleServiceFactory().getBatchRoles(roleIds, em)).map(
+        async (role) => {
+          return (em ?? this.em).merge(
+            await this.#mappers.RoleEntityMapper.deserializeDtoToEntity(
+              role,
+              em ?? this.em
+            )
+          );
+        }
+      )
+    ) : [];
+  }
+  // end: global helper functions
+  // start: createPermission helper functions
+  async createPermissionDto({
+    permission,
+    addToRoles
+  }) {
+    let roles = [];
+    if (addToRoles) {
+      roles = await this.updateRolesWithPermissions(addToRoles, [permission]);
+    }
+    return { permission, roles };
+  }
+  async extractCreatePermissionDtoToEntityData(permissionDto, em) {
+    return {
+      permission: (em ?? this.em).merge(
+        await this.#mappers.CreatePermissionDtoMapper.deserializeDtoToEntity(
+          permissionDto,
+          em ?? this.em
+        )
+      ),
+      addToRoles: permissionDto.addToRolesIds ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em) : []
+    };
+  }
+  // end: createPermission helper functions
+  async createPermission(createPermissionDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating permission",
+        createPermissionDto
+      );
+    }
+    const { permission, roles } = await this.createPermissionDto(
+      await this.extractCreatePermissionDtoToEntityData(createPermissionDto, em)
+    );
+    if (em) {
+      await em.persist([permission, ...roles]);
+    } else {
+      await this.em.persistAndFlush([permission, ...roles]);
+    }
+    return this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission);
+  }
+  async createBatchPermissions(permissionDtos, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating batch permissions",
+        permissionDtos
+      );
+    }
+    const rolesCache = {};
+    const permissions = [];
+    permissionDtos.map(async (createPermissionDto) => {
+      const { permission, roles } = await this.createPermissionDto(
+        await this.extractCreatePermissionDtoToEntityData(
+          createPermissionDto,
+          em
+        )
+      );
+      roles.forEach((role) => {
+        if (rolesCache[role.id] && role.permissions !== rolesCache[role.id].permissions) {
+          role.permissions.getItems().forEach((permission2) => {
+            if (!rolesCache[role.id].permissions.contains(permission2)) {
+              rolesCache[role.id].permissions.add(permission2);
+            }
+          });
+        } else {
+          rolesCache[role.id] = role;
+        }
+      });
+      permissions.push(permission);
+    });
+    const entities = [...permissions, ...Object.values(rolesCache)];
+    if (em) {
+      await em.persist(entities);
+    } else {
+      await this.em.persistAndFlush(entities);
+    }
+    return Promise.all(
+      permissions.map(
+        async (permission) => this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission)
+      )
+    );
+  }
+  async getPermission(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting permission", idDto);
+    }
+    const permission = await (em ?? this.em).findOneOrFail("Permission", idDto);
+    return this.#mappers.PermissionDtoMapper.serializeEntityToDto(
+      permission
+    );
+  }
+  async getBatchPermissions(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting batch permissions", idsDto);
+    }
+    return Promise.all(
+      (await (em ?? this.em).find("Permission", idsDto)).map(
+        (permission) => this.#mappers.PermissionDtoMapper.serializeEntityToDto(
+          permission
+        )
+      )
+    );
+  }
+  // start: updatePermission helper functions
+  updatePermissionDto = async (permissionDto, em) => {
+    const permission = await this.#mappers.UpdatePermissionDtoMapper.deserializeDtoToEntity(
+      permissionDto,
+      em ?? this.em
+    );
+    const addToRoles = permissionDto.addToRolesIds ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em) : [];
+    const removeFromRoles = permissionDto.removeFromRolesIds ? await this.getBatchRoles({ ids: permissionDto.removeFromRolesIds }, em) : [];
+    let roles = [];
+    roles = roles.concat(
+      await this.updateRolesWithPermissions(addToRoles, [permission])
+    );
+    roles = roles.concat(
+      await this.removePermissionsFromRoles(removeFromRoles, [permission])
+    );
+    return {
+      permission,
+      roles
+    };
+  };
+  // end: updatePermission helper functions
+  async updatePermission(permissionDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating permission", permissionDto);
+    }
+    const { permission, roles } = await this.updatePermissionDto(permissionDto);
+    const entities = await (em ?? this.em).upsertMany([permission, ...roles]);
+    if (em) {
+      await em.persist(entities);
+    } else {
+      await this.em.persistAndFlush(entities);
+    }
+    return this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission);
+  }
+  async updateBatchPermissions(permissionDtos, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Updating batch permissions",
+        permissionDtos
+      );
+    }
+    const rolesCache = {};
+    const permissions = [];
+    await (em ?? this.em).transactional(async (em2) => {
+      permissionDtos.map(async (updatePermissionDto) => {
+        const { permission, roles } = await this.updatePermissionDto(updatePermissionDto);
+        roles.forEach((role) => {
+          if (rolesCache[role.id] && role.permissions !== rolesCache[role.id].permissions) {
+            role.permissions.getItems().forEach((permission2) => {
+              if (!rolesCache[role.id].permissions.contains(permission2)) {
+                rolesCache[role.id].permissions.add(permission2);
+              }
+            });
+          } else {
+            rolesCache[role.id] = role;
+          }
+        });
+        permissions.push(permission);
+      });
+      const entities = [...permissions, ...Object.values(rolesCache)];
+      if (em2) {
+        await em2.persist(entities);
+      } else {
+        await this.em.persistAndFlush(entities);
+      }
+    });
+    return Promise.all(
+      permissions.map(
+        (permission) => this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission)
+      )
+    );
+  }
+  async deletePermission(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting permission", idDto);
+    }
+    await (em ?? this.em).nativeDelete("Permission", idDto);
+  }
+  async deleteBatchPermissions(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting batch permissions", idsDto);
+    }
+    await (em ?? this.em).nativeDelete("Permission", {
+      id: { $in: idsDto.ids }
+    });
+  }
+};
+
+// services/role.service.ts
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions3
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper as transformIntoInternalDtoMapper3
+} from "@forklaunch/core/mappers";
+var BaseRoleService = class {
+  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.#mappers = transformIntoInternalDtoMapper3(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions3(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  async createRole(roleDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating role", roleDto);
+    }
+    const role = await this.#mappers.CreateRoleDtoMapper.deserializeDtoToEntity(
+      roleDto,
+      em ?? this.em
+    );
+    if (em) {
+      await em.persist(role);
+    } else {
+      await this.em.persistAndFlush(role);
+    }
+    return this.#mappers.RoleDtoMapper.serializeEntityToDto(role);
+  }
+  async createBatchRoles(roleDtos, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating batch roles", roleDtos);
+    }
+    const roles = await Promise.all(
+      roleDtos.map(
+        async (roleDto) => this.#mappers.CreateRoleDtoMapper.deserializeDtoToEntity(
+          roleDto,
+          em ?? this.em
+        )
+      )
+    );
+    if (em) {
+      await em.persist(roles);
+    } else {
+      await this.em.persistAndFlush(roles);
+    }
+    return Promise.all(
+      roles.map(
+        (role) => this.#mappers.RoleDtoMapper.serializeEntityToDto(role)
+      )
+    );
+  }
+  async getRole({ id }, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting role", { id });
+    }
+    const role = await (em ?? this.em).findOneOrFail("Role", id, {
+      populate: ["id", "*"]
+    });
+    return this.#mappers.RoleDtoMapper.serializeEntityToDto(
+      role
+    );
+  }
+  async getBatchRoles({ ids }, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting batch roles", { ids });
+    }
+    return Promise.all(
+      (await (em ?? this.em).find(
+        "Role",
+        {
+          id: { $in: ids }
+        },
+        {
+          populate: ["id", "*"]
+        }
+      )).map(
+        (role) => this.#mappers.RoleDtoMapper.serializeEntityToDto(
+          role
+        )
+      )
+    );
+  }
+  async updateRole(roleDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating role", roleDto);
+    }
+    const role = await this.#mappers.UpdateRoleDtoMapper.deserializeDtoToEntity(
+      roleDto,
+      em ?? this.em
+    );
+    if (em) {
+      await em.persist(role);
+    } else {
+      await this.em.persistAndFlush(role);
+    }
+    return this.#mappers.RoleDtoMapper.serializeEntityToDto(role);
+  }
+  async updateBatchRoles(roleDtos, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating batch roles", roleDtos);
+    }
+    const roles = await Promise.all(
+      roleDtos.map(
+        async (roleDto) => this.#mappers.UpdateRoleDtoMapper.deserializeDtoToEntity(
+          roleDto,
+          em ?? this.em
+        )
+      )
+    );
+    if (em) {
+      await em.persist(roles);
+    } else {
+      await this.em.persistAndFlush(roles);
+    }
+    return Promise.all(
+      roles.map(
+        (role) => this.#mappers.RoleDtoMapper.serializeEntityToDto(
+          role
+        )
+      )
+    );
+  }
+  async deleteRole(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting role", idDto);
+    }
+    await (em ?? this.em).nativeDelete("Role", idDto);
+  }
+  async deleteBatchRoles(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting batch roles", idsDto);
+    }
+    await (em ?? this.em).nativeDelete("Role", { id: { $in: idsDto.ids } });
+  }
+};
+
+// services/user.service.ts
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions4
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper as transformIntoInternalDtoMapper4
+} from "@forklaunch/core/mappers";
+var BaseUserService = class {
+  constructor(em, passwordEncryptionPublicKeyPath, roleServiceFactory, organizationServiceFactory, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.passwordEncryptionPublicKeyPath = passwordEncryptionPublicKeyPath;
+    this.roleServiceFactory = roleServiceFactory;
+    this.organizationServiceFactory = organizationServiceFactory;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = transformIntoInternalDtoMapper4(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions4(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  async createUser(userDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating user", userDto);
+    }
+    const user = await this.#mappers.CreateUserDtoMapper.deserializeDtoToEntity(
+      userDto,
+      em ?? this.em
+    );
+    if (em) {
+      await em.persist(user);
+    } else {
+      await this.em.persistAndFlush(user);
+    }
+    return this.#mappers.UserDtoMapper.serializeEntityToDto(user);
+  }
+  async createBatchUsers(userDtos, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating batch users", userDtos);
+    }
+    const users = await Promise.all(
+      userDtos.map(
+        async (createUserDto) => this.#mappers.CreateUserDtoMapper.deserializeDtoToEntity(
+          createUserDto,
+          em ?? this.em
+        )
+      )
+    );
+    if (em) {
+      await em.persist(users);
+    } else {
+      await this.em.persistAndFlush(users);
+    }
+    return Promise.all(
+      users.map(
+        (user) => this.#mappers.UserDtoMapper.serializeEntityToDto(user)
+      )
+    );
+  }
+  async getUser(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting user", idDto);
+    }
+    const user = await (em ?? this.em).findOneOrFail("User", idDto, {
+      populate: ["id", "*"]
+    });
+    return this.#mappers.UserDtoMapper.serializeEntityToDto(
+      user
+    );
+  }
+  async getBatchUsers(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting batch users", idsDto);
+    }
+    return Promise.all(
+      (await (em ?? this.em).find("User", idsDto, {
+        populate: ["id", "*"]
+      })).map(
+        (user) => this.#mappers.UserDtoMapper.serializeEntityToDto(
+          user
+        )
+      )
+    );
+  }
+  async updateUser(userDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating user", userDto);
+    }
+    const user = await this.#mappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+      userDto,
+      em ?? this.em
+    );
+    if (em) {
+      await em.persist(user);
+    } else {
+      await this.em.persistAndFlush(user);
+    }
+    return this.#mappers.UserDtoMapper.serializeEntityToDto(user);
+  }
+  async updateBatchUsers(userDtos, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating batch users", userDtos);
+    }
+    const users = await Promise.all(
+      userDtos.map(
+        async (updateUserDto) => this.#mappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+          updateUserDto,
+          em ?? this.em
+        )
+      )
+    );
+    if (em) {
+      await em.persist(users);
+    } else {
+      await this.em.persistAndFlush(users);
+    }
+    return Promise.all(
+      users.map(
+        (user) => this.#mappers.UserDtoMapper.serializeEntityToDto(user)
+      )
+    );
+  }
+  async deleteUser(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting user", idDto);
+    }
+    await (em ?? this.em).nativeDelete("User", idDto);
+  }
+  async deleteBatchUsers(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting batch users", idsDto);
+    }
+    await (em ?? this.em).nativeDelete("User", idsDto);
+  }
+  async verifyHasRole(idDto, roleId) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Verifying user has role", {
+        idDto,
+        roleId
+      });
+    }
+    const user = await this.getUser(idDto);
+    if (user.roles.filter((role) => {
+      return roleId == role.id;
+    }).length === 0) {
+      throw new Error(`User ${idDto.id} does not have role ${roleId}`);
+    }
+  }
+  async verifyHasPermission(idDto, permissionId) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Verifying user has permission", {
+        idDto,
+        permissionId
+      });
+    }
+    const user = await this.getUser(idDto);
+    if (user.roles.map((role) => role.permissions.map((permission) => permission.id)).flat().filter((id) => id == permissionId).length === 0) {
+      throw new Error(
+        `User ${idDto.id} does not have permission ${permissionId}`
+      );
+    }
+  }
+};
+export {
+  BaseOrganizationService,
+  BasePermissionService,
+  BaseRoleService,
+  BaseUserService
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/implementation-iam-base",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Billing basic implementation for forklaunch",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {
@@ -15,13 +15,15 @@
   "exports": {
     "./schemas": {
       "types": "./lib/schemas/index.d.ts",
-      "import": "./lib/schemas/index.js",
-      "require": "./lib/schemas/index.js"
+      "import": "./lib/schemas/index.mjs",
+      "require": "./lib/schemas/index.js",
+      "default": "./lib/schemas/index.js"
     },
     "./services": {
       "types": "./lib/services/index.d.ts",
-      "import": "./lib/services/index.js",
-      "require": "./lib/services/index.js"
+      "import": "./lib/services/index.mjs",
+      "require": "./lib/services/index.js",
+      "default": "./lib/services/index.js"
     }
   },
   "files": [
@@ -29,21 +31,22 @@
   ],
   "dependencies": {
     "@forklaunch/common": "^0.3.11",
-    "@forklaunch/core": "^0.9.12",
-    "@forklaunch/validator": "^0.6.11",
+    "@forklaunch/core": "^0.9.15",
+    "@forklaunch/validator": "^0.6.13",
     "@mikro-orm/core": "^6.4.16",
     "@sinclair/typebox": "^0.34.33",
     "ajv": "^8.17.1",
-    "zod": "^3.25.62",
-    "@forklaunch/interfaces-iam": "0.2.3"
+    "zod": "^3.25.63",
+    "@forklaunch/interfaces-iam": "0.3.1"
   },
   "devDependencies": {
+    "@typescript/native-preview": "7.0.0-dev.20250611.1",
     "depcheck": "^1.4.7",
     "prettier": "^3.5.3",
     "typedoc": "^0.28.5"
   },
   "scripts": {
-    "build": "tsc && if [ -f eject-package.bash ]; then pnpm package:eject; fi",
+    "build": "tsc --noEmit && tsup schemas/index.ts services/index.ts --format cjs,esm --no-splitting --dts --tsconfig tsconfig.json --out-dir lib --clean && if [ -f eject-package.bash ]; then pnpm package:eject; fi",
     "clean": "rm -rf lib pnpm.lock.yaml node_modules",
     "docs": "typedoc --out docs *",
     "format": "prettier --ignore-path=.prettierignore --config .prettierrc '**/*.{ts,tsx,json}' --write",

package/lib/__test__/schemaEquality.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=schemaEquality.test.d.ts.map