@prosopo/user-access-policy 3.3.0 → 3.3.1

package/dist/index.js

@@ -1,15 +1,28 @@
-import { AccessPolicyType, accessPolicySchema, policyScopeSchema, } from "#policy/accessPolicy.js";
-import { createAccessPolicyResolver, } from "#policy/accessPolicyResolver.js";
-import { ScopeMatch } from "#policy/accessPolicyResolver.js";
-import { AccessRuleApiRoutes, accessRuleApiPaths, getExpressApiRuleRateLimits, } from "#policy/api/accessRuleApiRoutes.js";
-import { deleteAllRulesEndpointSchema, } from "#policy/api/deleteAllRulesEndpoint.js";
-import { deleteRulesEndpointSchema, } from "#policy/api/deleteRulesEndpoint.js";
-import { insertRulesEndpointSchema, } from "#policy/api/insertRulesEndpoint.js";
-import { createRedisAccessRulesStorage } from "#policy/redis/redisAccessRules.js";
-import { createRedisAccessRulesIndex } from "#policy/redis/redisAccessRulesIndex.js";
-import { userScopeInputSchema } from "./accessPolicy.js";
-export const createApiRuleRoutesProvider = (rulesStorage) => {
-    return new AccessRuleApiRoutes(rulesStorage);
+import { AccessPolicyType, accessPolicySchema, policyScopeSchema, userScopeInputSchema } from "./accessPolicy.js";
+import { ScopeMatch, createAccessPolicyResolver } from "./accessPolicyResolver.js";
+import { AccessRuleApiRoutes } from "./api/accessRuleApiRoutes.js";
+import { accessRuleApiPaths, getExpressApiRuleRateLimits } from "./api/accessRuleApiRoutes.js";
+import { deleteAllRulesEndpointSchema } from "./api/deleteAllRulesEndpoint.js";
+import { deleteRulesEndpointSchema } from "./api/deleteRulesEndpoint.js";
+import { insertRulesEndpointSchema } from "./api/insertRulesEndpoint.js";
+import { createRedisAccessRulesStorage } from "./redis/redisAccessRules.js";
+import { createRedisAccessRulesIndex } from "./redis/redisAccessRulesIndex.js";
+const createApiRuleRoutesProvider = (rulesStorage) => {
+  return new AccessRuleApiRoutes(rulesStorage);
+};
+export {
+  AccessPolicyType,
+  ScopeMatch,
+  accessPolicySchema,
+  accessRuleApiPaths,
+  createAccessPolicyResolver,
+  createApiRuleRoutesProvider,
+  createRedisAccessRulesIndex,
+  createRedisAccessRulesStorage,
+  deleteAllRulesEndpointSchema,
+  deleteRulesEndpointSchema,
+  getExpressApiRuleRateLimits,
+  insertRulesEndpointSchema,
+  policyScopeSchema,
+  userScopeInputSchema
 };
-export { createAccessPolicyResolver, AccessPolicyType, ScopeMatch, createRedisAccessRulesIndex, createRedisAccessRulesStorage, accessRuleApiPaths, accessPolicySchema, policyScopeSchema, insertRulesEndpointSchema, deleteAllRulesEndpointSchema, deleteRulesEndpointSchema, getExpressApiRuleRateLimits, userScopeInputSchema, };
-//# sourceMappingURL=index.js.map

package/dist/redis/redisAccessRules.js

@@ -1,119 +1,135 @@
 import * as util from "node:util";
-import { accessRuleSchema, } from "#policy/accessRules.js";
-import { accessRuleRedisKeyPrefix, accessRulesRedisIndexName, accessRulesRedisSearchOptions, getRedisAccessRuleKey, getRedisAccessRuleValue, getRedisAccessRulesQuery, } from "#policy/redis/redisAccessRulesIndex.js";
-export const createRedisAccessRulesReader = (client, logger) => {
-    return {
-        findRules: async (filter, skipEmptyUserScopes = true) => {
-            const query = getRedisAccessRulesQuery(filter);
-            if (skipEmptyUserScopes && query === "ismissing(@clientId)") {
-                return [];
+import { accessRuleSchema } from "../accessRules.js";
+import { getRedisAccessRulesQuery, accessRulesRedisIndexName, accessRulesRedisSearchOptions, accessRuleRedisKeyPrefix, getRedisAccessRuleKey, getRedisAccessRuleValue } from "./redisAccessRulesIndex.js";
+const createRedisAccessRulesReader = (client, logger) => {
+  return {
+    findRules: async (filter, skipEmptyUserScopes = true) => {
+      const query = getRedisAccessRulesQuery(filter);
+      if (skipEmptyUserScopes && query === "ismissing(@clientId)") {
+        return [];
+      }
+      let searchReply;
+      try {
+        searchReply = await client.ft.search(
+          accessRulesRedisIndexName,
+          query,
+          accessRulesRedisSearchOptions
+        );
+        if (searchReply.total > 0) {
+          logger.debug(() => ({
+            msg: "Executed search query",
+            data: {
+              inspect: util.inspect(
+                {
+                  filter,
+                  searchReply,
+                  query
+                },
+                { depth: null }
+              )
             }
-            let searchReply;
-            try {
-                searchReply = await client.ft.search(accessRulesRedisIndexName, query, accessRulesRedisSearchOptions);
-                if (searchReply.total > 0) {
-                    logger.debug(() => ({
-                        msg: "Executed search query",
-                        data: {
-                            inspect: util.inspect({
-                                filter: filter,
-                                searchReply: searchReply,
-                                query: query,
-                            }, { depth: null }),
-                        },
-                    }));
-                }
-            }
-            catch (e) {
-                logger.error(() => ({
-                    err: e,
-                    data: {
-                        inspect: util.inspect({
-                            query: query,
-                            filter: filter,
-                        }, {
-                            depth: null,
-                        }),
-                    },
-                    msg: "failed to execute search query",
-                }));
-                return [];
-            }
-            return extractAccessRulesFromSearchReply(searchReply, logger);
-        },
-        findRuleIds: async (filter) => {
-            const query = getRedisAccessRulesQuery(filter);
-            let searchReply;
-            try {
-                searchReply = await client.ft.searchNoContent(accessRulesRedisIndexName, query, accessRulesRedisSearchOptions);
-            }
-            catch (e) {
-                logger.error(() => ({
-                    err: e,
-                    data: {
-                        inspect: util.inspect({
-                            query: query,
-                            filter: filter,
-                        }, {
-                            depth: null,
-                        }),
-                    },
-                    msg: "Failed to execute search query for rule IDs",
-                }));
-                return [];
-            }
-            return searchReply.documents;
-        },
-    };
+          }));
+        }
+      } catch (e) {
+        logger.error(() => ({
+          err: e,
+          data: {
+            inspect: util.inspect(
+              {
+                query,
+                filter
+              },
+              {
+                depth: null
+              }
+            )
+          },
+          msg: "failed to execute search query"
+        }));
+        return [];
+      }
+      return extractAccessRulesFromSearchReply(searchReply, logger);
+    },
+    findRuleIds: async (filter) => {
+      const query = getRedisAccessRulesQuery(filter);
+      let searchReply;
+      try {
+        searchReply = await client.ft.searchNoContent(
+          accessRulesRedisIndexName,
+          query,
+          accessRulesRedisSearchOptions
+        );
+      } catch (e) {
+        logger.error(() => ({
+          err: e,
+          data: {
+            inspect: util.inspect(
+              {
+                query,
+                filter
+              },
+              {
+                depth: null
+              }
+            )
+          },
+          msg: "Failed to execute search query for rule IDs"
+        }));
+        return [];
+      }
+      return searchReply.documents;
+    }
+  };
 };
-export const createRedisAccessRulesWriter = (client) => {
-    return {
-        insertRule: async (rule, expirationTimestamp) => {
-            const ruleKey = getRedisAccessRuleKey(rule);
-            const ruleValue = getRedisAccessRuleValue(rule);
-            await client.hSet(ruleKey, ruleValue);
-            if (expirationTimestamp) {
-                const expiryDate = new Date(expirationTimestamp);
-                if (expiryDate.getUTCFullYear() === 1970) {
-                    await client.expireAt(ruleKey, expirationTimestamp);
-                }
-                else {
-                    const timestampInSeconds = Math.floor(expirationTimestamp / 1000);
-                    await client.expireAt(ruleKey, timestampInSeconds);
-                }
-            }
-            return ruleKey;
-        },
-        deleteRules: async (ruleIds) => void (await client.del(ruleIds)),
-        deleteAllRules: async () => {
-            const keys = await client.keys(`${accessRuleRedisKeyPrefix}*`);
-            if (keys.length === 0)
-                return 0;
-            return await client.del(keys);
-        },
-    };
+const createRedisAccessRulesWriter = (client) => {
+  return {
+    insertRule: async (rule, expirationTimestamp) => {
+      const ruleKey = getRedisAccessRuleKey(rule);
+      const ruleValue = getRedisAccessRuleValue(rule);
+      await client.hSet(ruleKey, ruleValue);
+      if (expirationTimestamp) {
+        const expiryDate = new Date(expirationTimestamp);
+        if (expiryDate.getUTCFullYear() === 1970) {
+          await client.expireAt(ruleKey, expirationTimestamp);
+        } else {
+          const timestampInSeconds = Math.floor(expirationTimestamp / 1e3);
+          await client.expireAt(ruleKey, timestampInSeconds);
+        }
+      }
+      return ruleKey;
+    },
+    deleteRules: async (ruleIds) => void await client.del(ruleIds),
+    deleteAllRules: async () => {
+      const keys = await client.keys(`${accessRuleRedisKeyPrefix}*`);
+      if (keys.length === 0) return 0;
+      return await client.del(keys);
+    }
+  };
 };
-export const createRedisAccessRulesStorage = (client, logger) => {
-    return {
-        ...createRedisAccessRulesReader(client, logger),
-        ...createRedisAccessRulesWriter(client),
-    };
+const createRedisAccessRulesStorage = (client, logger) => {
+  return {
+    ...createRedisAccessRulesReader(client, logger),
+    ...createRedisAccessRulesWriter(client)
+  };
 };
 const extractAccessRulesFromSearchReply = (searchReply, logger) => {
-    const accessRules = [];
-    searchReply.documents.map(({ id, value: document }) => {
-        const parsedDocument = accessRuleSchema.safeParse(document);
-        if (parsedDocument.success) {
-            accessRules.push(parsedDocument.data);
-        }
-        else {
-            logger.debug(() => ({
-                msg: "Failed to parse access rule from search reply",
-                id: id,
-                error: parsedDocument.error,
-            }));
-        }
-    });
-    return accessRules;
+  const accessRules = [];
+  searchReply.documents.map(({ id, value: document }) => {
+    const parsedDocument = accessRuleSchema.safeParse(document);
+    if (parsedDocument.success) {
+      accessRules.push(parsedDocument.data);
+    } else {
+      logger.debug(() => ({
+        msg: "Failed to parse access rule from search reply",
+        id,
+        error: parsedDocument.error
+      }));
+    }
+  });
+  return accessRules;
+};
+export {
+  createRedisAccessRulesReader,
+  createRedisAccessRulesStorage,
+  createRedisAccessRulesWriter
 };
-//# sourceMappingURL=redisAccessRules.js.map

package/dist/redis/redisAccessRulesIndex.js

@@ -1,89 +1,113 @@
 import crypto from "node:crypto";
 import { SCHEMA_FIELD_TYPE } from "@redis/search";
-import { ScopeMatch } from "#policy/accessPolicyResolver.js";
-import { createRedisIndex } from "#policy/redis/redisIndex.js";
-export const accessRulesRedisIndexName = "index:user-access-rules";
-export const accessRuleRedisKeyPrefix = "uar:";
+import { ScopeMatch } from "../accessPolicyResolver.js";
+import { createRedisIndex } from "./redisIndex.js";
+const accessRulesRedisIndexName = "index:user-access-rules";
+const accessRuleRedisKeyPrefix = "uar:";
 const accessRuleContentHashAlgorithm = "md5";
-const DEFAULT_SEARCH_LIMIT = 1000;
+const DEFAULT_SEARCH_LIMIT = 1e3;
 const accessRulesIndex = {
-    name: accessRulesRedisIndexName,
-    schema: {
-        clientId: {
-            type: SCHEMA_FIELD_TYPE.TAG,
-            INDEXMISSING: true,
-        },
-        numericIpMaskMin: SCHEMA_FIELD_TYPE.NUMERIC,
-        numericIpMaskMax: SCHEMA_FIELD_TYPE.NUMERIC,
-        userId: SCHEMA_FIELD_TYPE.TAG,
-        numericIp: { type: SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true },
-        ja4Hash: SCHEMA_FIELD_TYPE.TAG,
-        headersHash: SCHEMA_FIELD_TYPE.TAG,
-        userAgentHash: SCHEMA_FIELD_TYPE.TAG,
-    },
-    options: {
-        ON: "HASH",
-        PREFIX: [accessRuleRedisKeyPrefix],
+  name: accessRulesRedisIndexName,
+  /**
+   * Note on the field type decision
+   *
+   * TAG is designed for the exact value matching
+   * TEXT is designed for the word-based and pattern matching
+   *
+   * For our goal TAG fits perfectly and, more performant
+   */
+  schema: {
+    clientId: {
+      type: SCHEMA_FIELD_TYPE.TAG,
+      // necessary to make possible use of the ismissing() function on this field in the search
+      INDEXMISSING: true
     },
+    numericIpMaskMin: SCHEMA_FIELD_TYPE.NUMERIC,
+    numericIpMaskMax: SCHEMA_FIELD_TYPE.NUMERIC,
+    userId: SCHEMA_FIELD_TYPE.TAG,
+    numericIp: { type: SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true },
+    ja4Hash: SCHEMA_FIELD_TYPE.TAG,
+    headersHash: SCHEMA_FIELD_TYPE.TAG,
+    userAgentHash: SCHEMA_FIELD_TYPE.TAG
+  },
+  // the satisfy statement is to guarantee that the keys are right
+  options: {
+    ON: "HASH",
+    PREFIX: [accessRuleRedisKeyPrefix]
+  }
 };
-export const createRedisAccessRulesIndex = async (client) => createRedisIndex(client, accessRulesIndex);
+const createRedisAccessRulesIndex = async (client) => createRedisIndex(client, accessRulesIndex);
 const numericIndexFields = [
-    "numericIp",
-    "numericIpMaskMin",
-    "numericIpMaskMax",
+  "numericIp",
+  "numericIpMaskMin",
+  "numericIpMaskMax"
 ];
 const greedyFieldComparisons = {
-    numericIp: (value) => `( @numericIp:[${value}] | ( @numericIpMaskMin:[-inf ${value}] @numericIpMaskMax:[${value} +inf] ) )`,
+  numericIp: (value) => `( @numericIp:[${value}] | ( @numericIpMaskMin:[-inf ${value}] @numericIpMaskMax:[${value} +inf] ) )`
 };
-export const accessRulesRedisSearchOptions = {
-    DIALECT: 2,
+const accessRulesRedisSearchOptions = {
+  // #2 is a required option when the 'ismissing()' function is in the query body
+  DIALECT: 2
 };
-export const accessRulesRedisDeleteOptions = {
-    DIALECT: 2,
-    LIMIT: {
-        from: 0,
-        size: DEFAULT_SEARCH_LIMIT,
-    },
+const accessRulesRedisDeleteOptions = {
+  // #2 is a required option when the 'ismissing()' function is in the query body
+  DIALECT: 2,
+  LIMIT: {
+    from: 0,
+    size: DEFAULT_SEARCH_LIMIT
+  }
 };
-export const getRedisAccessRulesQuery = (filter) => {
-    const { policyScope, userScope } = filter;
-    const policyScopeFilter = getPolicyScopeQuery(policyScope, filter.policyScopeMatch);
-    if (userScope && Object.keys(userScope).length > 0) {
-        const userScopeFilter = getUserScopeQuery(userScope, filter.userScopeMatch);
-        return `${policyScopeFilter} ( ${userScopeFilter} )`;
-    }
-    return policyScopeFilter ? policyScopeFilter : "*";
+const getRedisAccessRulesQuery = (filter) => {
+  const { policyScope, userScope } = filter;
+  const policyScopeFilter = getPolicyScopeQuery(
+    policyScope,
+    filter.policyScopeMatch
+  );
+  if (userScope && Object.keys(userScope).length > 0) {
+    const userScopeFilter = getUserScopeQuery(userScope, filter.userScopeMatch);
+    return `${policyScopeFilter} ( ${userScopeFilter} )`;
+  }
+  return policyScopeFilter ? policyScopeFilter : "*";
 };
 const getPolicyScopeQuery = (policyScope, scopeMatchType) => {
-    const clientId = policyScope?.clientId;
-    if ("string" === typeof clientId) {
-        return ScopeMatch.Exact === scopeMatchType
-            ? `@clientId:{${clientId}}`
-            : `( @clientId:{${clientId}} | ismissing(@clientId) )`;
-    }
-    return ScopeMatch.Exact === scopeMatchType ? "ismissing(@clientId)" : "";
+  const clientId = policyScope?.clientId;
+  if ("string" === typeof clientId) {
+    return ScopeMatch.Exact === scopeMatchType ? `@clientId:{${clientId}}` : `( @clientId:{${clientId}} | ismissing(@clientId) )`;
+  }
+  return ScopeMatch.Exact === scopeMatchType ? "ismissing(@clientId)" : "";
 };
 const getUserScopeQuery = (userScope, scopeMatchType) => {
-    const scopeEntries = Object.entries(userScope)
-        .filter(([_, value]) => value !== undefined);
-    const scopeJoinType = ScopeMatch.Exact === scopeMatchType ? " " : " | ";
-    return scopeEntries
-        .map(([scopeFieldName, scopeFieldValue]) => getUserScopeFieldQuery(scopeFieldName, scopeFieldValue, scopeMatchType))
-        .join(scopeJoinType);
+  const scopeEntries = Object.entries(userScope).filter(([_, value]) => value !== void 0);
+  const scopeJoinType = ScopeMatch.Exact === scopeMatchType ? " " : " | ";
+  return scopeEntries.map(
+    ([scopeFieldName, scopeFieldValue]) => getUserScopeFieldQuery(scopeFieldName, scopeFieldValue, scopeMatchType)
+  ).join(scopeJoinType);
 };
 const getUserScopeFieldQuery = (fieldName, fieldValue, matchType) => {
-    if (ScopeMatch.Greedy === matchType &&
-        "function" === typeof greedyFieldComparisons[fieldName]) {
-        return greedyFieldComparisons[fieldName](fieldValue);
-    }
-    return numericIndexFields.includes(fieldName)
-        ? `@${fieldName}:[${fieldValue}]`
-        : `@${fieldName}:{${fieldValue}}`;
+  if (ScopeMatch.Greedy === matchType && "function" === typeof greedyFieldComparisons[fieldName]) {
+    return greedyFieldComparisons[fieldName](fieldValue);
+  }
+  return numericIndexFields.includes(fieldName) ? `@${fieldName}:[${fieldValue}]` : `@${fieldName}:{${fieldValue}}`;
+};
+const getRedisAccessRuleKey = (rule) => accessRuleRedisKeyPrefix + crypto.createHash(accessRuleContentHashAlgorithm).update(
+  JSON.stringify(
+    rule,
+    (key, value) => (
+      // JSON.stringify can't handle BigInt itself: throws "Do not know how to serialize a BigInt"
+      "bigint" === typeof value ? value.toString() : value
+    )
+  )
+).digest("hex");
+const getRedisAccessRuleValue = (rule) => Object.fromEntries(
+  Object.entries(rule).map(([key, value]) => [key, String(value)])
+);
+export {
+  accessRuleRedisKeyPrefix,
+  accessRulesRedisDeleteOptions,
+  accessRulesRedisIndexName,
+  accessRulesRedisSearchOptions,
+  createRedisAccessRulesIndex,
+  getRedisAccessRuleKey,
+  getRedisAccessRuleValue,
+  getRedisAccessRulesQuery
 };
-export const getRedisAccessRuleKey = (rule) => accessRuleRedisKeyPrefix +
-    crypto
-        .createHash(accessRuleContentHashAlgorithm)
-        .update(JSON.stringify(rule, (key, value) => "bigint" === typeof value ? value.toString() : value))
-        .digest("hex");
-export const getRedisAccessRuleValue = (rule) => Object.fromEntries(Object.entries(rule).map(([key, value]) => [key, String(value)]));
-//# sourceMappingURL=redisAccessRulesIndex.js.map

package/dist/redis/redisIndex.js

@@ -1,23 +1,22 @@
 import crypto from "node:crypto";
 const redisIndexHashesRecordKey = "_index_hashes";
 const redisIndexHashAlgorithm = "sha256";
-export const createRedisIndex = async (client, index) => {
-    const indexHash = createIndexHash(index);
-    const existingIndexes = await client.ft._LIST();
-    if (existingIndexes.includes(index.name)) {
-        const existingIndexHash = await fetchIndexHash(client, index.name);
-        if (indexHash === existingIndexHash) {
-            return;
-        }
-        await client.ft.dropIndex(index.name);
+const createRedisIndex = async (client, index) => {
+  const indexHash = createIndexHash(index);
+  const existingIndexes = await client.ft._LIST();
+  if (existingIndexes.includes(index.name)) {
+    const existingIndexHash = await fetchIndexHash(client, index.name);
+    if (indexHash === existingIndexHash) {
+      return;
     }
-    await client.ft.create(index.name, index.schema, index.options);
-    await saveIndexHash(client, index.name, indexHash);
+    await client.ft.dropIndex(index.name);
+  }
+  await client.ft.create(index.name, index.schema, index.options);
+  await saveIndexHash(client, index.name, indexHash);
 };
-const createIndexHash = (index) => crypto
-    .createHash(redisIndexHashAlgorithm)
-    .update(JSON.stringify(index))
-    .digest("hex");
+const createIndexHash = (index) => crypto.createHash(redisIndexHashAlgorithm).update(JSON.stringify(index)).digest("hex");
 const fetchIndexHash = async (client, indexName) => client.hGet(redisIndexHashesRecordKey, indexName);
 const saveIndexHash = async (client, indexName, indexHash) => client.hSet(redisIndexHashesRecordKey, indexName, indexHash);
-//# sourceMappingURL=redisIndex.js.map
+export {
+  createRedisIndex
+};

package/dist/util.js

@@ -1,3 +1,5 @@
 import crypto from "node:crypto";
-export const hashUserAgent = (userAgent) => crypto.createHash("sha256").update(userAgent).digest("hex");
-//# sourceMappingURL=util.js.map
+const hashUserAgent = (userAgent) => crypto.createHash("sha256").update(userAgent).digest("hex");
+export {
+  hashUserAgent
+};

package/package.json

@@ -1,7 +1,8 @@
 {
 	"name": "@prosopo/user-access-policy",
-	"version": "3.3.0",
+	"version": "3.3.1",
 	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
 	"type": "module",
 	"engines": {
 		"node": "20",
@@ -9,6 +10,7 @@
 	},
 	"exports": {
 		".": {
+			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js",
 			"require": "./dist/cjs/index.cjs"
 		}
@@ -17,22 +19,25 @@
 		"#policy/*": "./dist/*"
 	},
 	"scripts": {
-		"build": "tsc --build --verbose",
-		"clean": "tsc --build --clean",
-		"build:cjs": "npx vite build --config vite.cjs.config.ts",
+		"clean": "del-cli --verbose dist tsconfig.tsbuildinfo",
+		"build": "NODE_ENV=${NODE_ENV:-production}; vite build --config vite.esm.config.ts --mode $NODE_ENV",
+		"build:tsc": "tsc --build --verbose",
+		"build:cjs": "NODE_ENV=${NODE_ENV:-production}; vite build --config vite.cjs.config.ts --mode $NODE_ENV",
+		"typecheck": "tsc --build --declaration --emitDeclarationOnly",
 		"test": "NODE_ENV=${NODE_ENV:-test}; npx vitest run --config ./vite.test.config.ts"
 	},
 	"dependencies": {
-		"@prosopo/api-route": "2.6.7",
-		"@prosopo/common": "3.0.2",
-		"@prosopo/types": "3.0.3",
-		"@prosopo/util": "3.0.2",
+		"@prosopo/api-route": "2.6.8",
+		"@prosopo/common": "3.1.0",
+		"@prosopo/types": "3.0.4",
+		"@prosopo/util": "3.0.3",
 		"axios": "1.10.0",
 		"esbuild": "0.25.6",
 		"ip-address": "10.0.1",
 		"redis": "5.0.0",
-		"webpack-dev-server": "5.2.2",
-		"zod": "3.23.8"
+		"zod": "3.23.8",
+		"@prosopo/config": "3.1.1",
+		"webpack-dev-server": "5.2.2"
 	},
 	"devDependencies": {
 		"vite": "6.3.5",

package/vite.cjs.config.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 // Copyright 2021-2025 Prosopo (UK) Ltd.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -11,11 +12,11 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
-import path from "node:path";
 import { ViteCommonJSConfig } from "@prosopo/config";
 
-export default ViteCommonJSConfig(
-	"user-access-policy",
-	path.resolve("./tsconfig.cjs.json"),
-);
+export default function () {
+	return ViteCommonJSConfig(
+		path.basename("."),
+		path.resolve("./tsconfig.json"),
+	);
+}

package/vite.esm.config.ts

@@ -0,0 +1,20 @@
+// Copyright 2021-2025 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import path from "node:path";
+import { ViteEsmConfig } from "@prosopo/config";
+
+export default function () {
+	return ViteEsmConfig(path.basename("."), path.resolve("./tsconfig.json"));
+}