@forklaunch/implementation-billing-base 0.2.3 → 0.3.0

package/lib/services/index.mjs

@@ -0,0 +1,599 @@
+// services/billingPortal.service.ts
+import { createCacheKey } from "@forklaunch/core/cache";
+import {
+  evaluateTelemetryOptions
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper
+} from "@forklaunch/core/mappers";
+var BaseBillingPortalService = class {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  enableDatabaseBackup;
+  createCacheKey = createCacheKey("billing_portal_session");
+  async createBillingPortalSession(billingPortalDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating billing portal session",
+        billingPortalDto
+      );
+    }
+    const billingPortal = await this.#mappers.CreateBillingPortalDtoMapper.deserializeDtoToEntity(
+      billingPortalDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(billingPortal);
+    }
+    const createdBillingPortalDto = await this.#mappers.BillingPortalDtoMapper.serializeEntityToDto(
+      billingPortal
+    );
+    await this.cache.putRecord({
+      key: this.createCacheKey(createdBillingPortalDto.id),
+      value: createdBillingPortalDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return createdBillingPortalDto;
+  }
+  async getBillingPortalSession(idDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting billing portal session", idDto);
+    }
+    const billingPortalDetails = await this.cache.readRecord(this.createCacheKey(idDto.id));
+    if (!billingPortalDetails) {
+      throw new Error("Session not found");
+    }
+    return billingPortalDetails.value;
+  }
+  async updateBillingPortalSession(billingPortalDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Updating billing portal session",
+        billingPortalDto
+      );
+    }
+    const existingBillingPortal = (await this.cache.readRecord(
+      this.createCacheKey(billingPortalDto.id)
+    ))?.value;
+    if (!existingBillingPortal) {
+      throw new Error("Session not found");
+    }
+    const billingPortal = await this.#mappers.UpdateBillingPortalDtoMapper.deserializeDtoToEntity(
+      billingPortalDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush({
+        billingPortal
+      });
+    }
+    const updatedBillingPortalDto = {
+      ...existingBillingPortal,
+      ...await this.#mappers.BillingPortalDtoMapper.serializeEntityToDto(
+        billingPortal
+      )
+    };
+    await this.cache.putRecord({
+      key: this.createCacheKey(updatedBillingPortalDto.id),
+      value: updatedBillingPortalDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return updatedBillingPortalDto;
+  }
+  async expireBillingPortalSession(idDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Expiring billing portal session",
+        idDto
+      );
+    }
+    const sessionExists = await this.cache.readRecord(
+      this.createCacheKey(idDto.id)
+    );
+    if (!sessionExists) {
+      throw new Error("Session not found");
+    }
+    await this.cache.deleteRecord(this.createCacheKey(idDto.id));
+  }
+};
+
+// services/checkoutSession.service.ts
+import { createCacheKey as createCacheKey2 } from "@forklaunch/core/cache";
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions2
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper as transformIntoInternalDtoMapper2
+} from "@forklaunch/core/mappers";
+var BaseCheckoutSessionService = class {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = transformIntoInternalDtoMapper2(mappers, schemaValidator);
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions2(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  enableDatabaseBackup;
+  createCacheKey = createCacheKey2("checkout_session");
+  async createCheckoutSession(checkoutSessionDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating checkout session",
+        checkoutSessionDto
+      );
+    }
+    const checkoutSession = await this.#mappers.CreateCheckoutSessionDtoMapper.deserializeDtoToEntity(
+      checkoutSessionDto,
+      this.em
+    );
+    const createdCheckoutSessionDto = await this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+      checkoutSession
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(checkoutSession);
+    }
+    await this.cache.putRecord({
+      key: this.createCacheKey(createdCheckoutSessionDto.id),
+      value: createdCheckoutSessionDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return createdCheckoutSessionDto;
+  }
+  async getCheckoutSession({
+    id
+  }) {
+    const checkoutSessionDetails = await this.cache.readRecord(this.createCacheKey(id));
+    if (!checkoutSessionDetails) {
+      throw new Error("Session not found");
+    }
+    return this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+      checkoutSessionDetails.value
+    );
+  }
+  async expireCheckoutSession({ id }) {
+    const checkoutSessionDetails = await this.cache.readRecord(
+      this.createCacheKey(id)
+    );
+    if (!checkoutSessionDetails) {
+      throw new Error("Session not found");
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handleCheckoutSuccess({ id }) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Checkout success", { id });
+    }
+    if (this.enableDatabaseBackup) {
+      const checkoutSession = await this.em.upsert("CheckoutSession", {
+        id,
+        status: "SUCCESS"
+      });
+      await this.em.persistAndFlush(checkoutSession);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handleCheckoutFailure({ id }) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Checkout failure", { id });
+    }
+    if (this.enableDatabaseBackup) {
+      const checkoutSession = await this.em.upsert("CheckoutSession", {
+        id,
+        status: "FAILED"
+      });
+      await this.em.persistAndFlush(checkoutSession);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+};
+
+// services/paymentLink.service.ts
+import { createCacheKey as createCacheKey3 } from "@forklaunch/core/cache";
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions3
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper as transformIntoInternalDtoMapper3
+} from "@forklaunch/core/mappers";
+var BasePaymentLinkService = class {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = transformIntoInternalDtoMapper3(mappers, schemaValidator);
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions3(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  enableDatabaseBackup;
+  cacheKeyPrefix = "payment_link";
+  createCacheKey = createCacheKey3(this.cacheKeyPrefix);
+  async createPaymentLink(paymentLinkDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating payment link", paymentLinkDto);
+    }
+    const paymentLink = await this.#mappers.CreatePaymentLinkDtoMapper.deserializeDtoToEntity(
+      paymentLinkDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(paymentLink);
+    }
+    const createdPaymentLinkDto = await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+      paymentLink
+    );
+    await this.cache.putRecord({
+      key: this.createCacheKey(createdPaymentLinkDto.id),
+      value: createdPaymentLinkDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return createdPaymentLinkDto;
+  }
+  async updatePaymentLink(paymentLinkDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating payment link", paymentLinkDto);
+    }
+    const cacheKey = this.createCacheKey(paymentLinkDto.id);
+    const existingLink = (await this.cache.readRecord(cacheKey))?.value;
+    if (!existingLink) {
+      throw new Error("Payment link not found");
+    }
+    const paymentLink = await this.#mappers.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
+      paymentLinkDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(paymentLink);
+    }
+    const updatedLinkDto = {
+      ...existingLink,
+      ...await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+        paymentLink
+      )
+    };
+    await this.cache.putRecord({
+      key: cacheKey,
+      value: updatedLinkDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return updatedLinkDto;
+  }
+  async getPaymentLink({ id }) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting payment link", { id });
+    }
+    const cacheKey = this.createCacheKey(id);
+    const paymentLink = await this.cache.readRecord(cacheKey);
+    if (!paymentLink) {
+      throw new Error("Payment link not found");
+    }
+    return this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+      paymentLink.value
+    );
+  }
+  async expirePaymentLink({ id }) {
+    this.openTelemetryCollector.info("Payment link expired", { id });
+    if (this.enableDatabaseBackup) {
+      const paymentLink = await this.em.upsert("PaymentLink", {
+        id,
+        status: "EXPIRED"
+      });
+      await this.em.removeAndFlush(paymentLink);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handlePaymentSuccess({ id }) {
+    this.openTelemetryCollector.info("Payment link success", { id });
+    if (this.enableDatabaseBackup) {
+      const paymentLink = await this.em.upsert("PaymentLink", {
+        id,
+        status: "COMPLETED"
+      });
+      await this.em.removeAndFlush(paymentLink);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handlePaymentFailure({ id }) {
+    this.openTelemetryCollector.info("Payment link failure", { id });
+    if (this.enableDatabaseBackup) {
+      const paymentLink = await this.em.upsert("PaymentLink", {
+        id,
+        status: "FAILED"
+      });
+      await this.em.removeAndFlush(paymentLink);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async listPaymentLinks(idsDto) {
+    const keys = idsDto?.ids.map((id) => this.createCacheKey(id)) ?? await this.cache.listKeys(this.cacheKeyPrefix);
+    return Promise.all(
+      keys.map(async (key) => {
+        const paymentLink = await this.cache.readRecord(key);
+        const paymentLinkDto = this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+          paymentLink.value
+        );
+        return paymentLinkDto;
+      })
+    );
+  }
+};
+
+// services/plan.service.ts
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions4
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper as transformIntoInternalDtoMapper4
+} from "@forklaunch/core/mappers";
+var BasePlanService = class {
+  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    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 listPlans(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Listing plans", idsDto);
+    }
+    return Promise.all(
+      (await (em ?? this.em).findAll("Plan", {
+        filters: idsDto?.ids ? { id: { $in: idsDto.ids } } : void 0
+      })).map(
+        (plan) => this.#mappers.PlanDtoMapper.serializeEntityToDto(
+          plan
+        )
+      )
+    );
+  }
+  async createPlan(planDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating plan", planDto);
+    }
+    const plan = await this.#mappers.CreatePlanDtoMapper.deserializeDtoToEntity(
+      planDto,
+      em ?? this.em
+    );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(plan);
+    });
+    return this.#mappers.PlanDtoMapper.serializeEntityToDto(plan);
+  }
+  async getPlan(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting plan", idDto);
+    }
+    const plan = await (em ?? this.em).findOneOrFail("Plan", idDto);
+    return this.#mappers.PlanDtoMapper.serializeEntityToDto(
+      plan
+    );
+  }
+  async updatePlan(planDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating plan", planDto);
+    }
+    const plan = await this.#mappers.UpdatePlanDtoMapper.deserializeDtoToEntity(
+      planDto,
+      em ?? this.em
+    );
+    const updatedPlan = await (em ?? this.em).upsert(plan);
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(plan);
+    });
+    const updatedPlanDto = await this.#mappers.PlanDtoMapper.serializeEntityToDto(updatedPlan);
+    return updatedPlanDto;
+  }
+  async deletePlan(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting plan", idDto);
+    }
+    await (em ?? this.em).nativeDelete("Plan", idDto);
+  }
+};
+
+// services/subscription.service.ts
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions5
+} from "@forklaunch/core/http";
+import {
+  transformIntoInternalDtoMapper as transformIntoInternalDtoMapper5
+} from "@forklaunch/core/mappers";
+var BaseSubscriptionService = class {
+  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = transformIntoInternalDtoMapper5(mappers, this.schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions5(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  async createSubscription(subscriptionDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating subscription",
+        subscriptionDto
+      );
+    }
+    const subscription = await this.#mappers.CreateSubscriptionDtoMapper.deserializeDtoToEntity(
+      subscriptionDto,
+      em ?? this.em
+    );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(subscription);
+    });
+    const createdSubscriptionDto = await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+    return createdSubscriptionDto;
+  }
+  async getSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOneOrFail(
+      "Subscription",
+      idDto
+    );
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+  }
+  async getUserSubscription({ id }, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting user subscription", id);
+    }
+    const subscription = await (em ?? this.em).findOneOrFail("Subscription", {
+      partyId: id,
+      partyType: "USER",
+      active: true
+    });
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+  }
+  async getOrganizationSubscription({ id }, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting organization subscription", id);
+    }
+    const subscription = await (em ?? this.em).findOneOrFail("Subscription", {
+      partyId: id,
+      partyType: "ORGANIZATION",
+      active: true
+    });
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+  }
+  async updateSubscription(subscriptionDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Updating subscription",
+        subscriptionDto
+      );
+    }
+    const subscription = this.#mappers.UpdateSubscriptionDtoMapper.deserializeDtoToEntity(
+      subscriptionDto,
+      em ?? this.em
+    );
+    const updatedSubscription = await (em ?? this.em).upsert(subscription);
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(updatedSubscription);
+    });
+    const updatedSubscriptionDto = await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      updatedSubscription
+    );
+    return updatedSubscriptionDto;
+  }
+  async deleteSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    if (!subscription) {
+      throw new Error("Subscription not found");
+    }
+    await (em ?? this.em).removeAndFlush(subscription);
+  }
+  async listSubscriptions(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Listing subscriptions", idsDto);
+    }
+    const subscriptions = await (em ?? this.em).findAll("Subscription", {
+      where: idsDto.ids ? {
+        id: {
+          $in: idsDto.ids
+        }
+      } : void 0
+    });
+    return Promise.all(
+      subscriptions.map((subscription) => {
+        const subscriptionDto = this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+          subscription
+        );
+        return subscriptionDto;
+      })
+    );
+  }
+  async cancelSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Canceling subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    if (!subscription) {
+      throw new Error("Subscription not found");
+    }
+    subscription.active = false;
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(subscription);
+    });
+  }
+  async resumeSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Resuming subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    if (!subscription) {
+      throw new Error("Subscription not found");
+    }
+    subscription.active = true;
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(subscription);
+    });
+  }
+};
+export {
+  BaseBillingPortalService,
+  BaseCheckoutSessionService,
+  BasePaymentLinkService,
+  BasePlanService,
+  BaseSubscriptionService
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/implementation-billing-base",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Billing basic implementation for forklaunch",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {
@@ -29,21 +29,22 @@
   ],
   "dependencies": {
     "@forklaunch/common": "^0.3.11",
-    "@forklaunch/core": "^0.9.12",
-    "@forklaunch/validator": "^0.6.11",
+    "@forklaunch/core": "^0.9.13",
+    "@forklaunch/validator": "^0.6.12",
     "@mikro-orm/core": "^6.4.16",
     "@sinclair/typebox": "^0.34.33",
     "ajv": "^8.17.1",
     "zod": "^3.25.62",
-    "@forklaunch/interfaces-billing": "0.2.3"
+    "@forklaunch/interfaces-billing": "0.3.0"
   },
   "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

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemaEquality.test.d.ts","sourceRoot":"","sources":["../../__test__/schemaEquality.test.ts"],"names":[],"mappings":""}