@c15t/backend 1.2.0-canary.13 → 1.2.0-canary.2

package/dist/schema/create-registry.d.ts

@@ -42,8 +42,8 @@ export declare const createRegistry: (ctx: RegistryContext) => {
         lastIpAddress?: string | undefined;
     } | null>;
     createConsentPolicy: (policy: Omit<import("./consent-policy").ConsentPolicy, "id" | "createdAt"> & Partial<import("./consent-policy").ConsentPolicy>, context?: import("../pkgs/types").GenericEndpointContext) => Promise<{
-        name: string;
         type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+        name: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -59,8 +59,8 @@ export declare const createRegistry: (ctx: RegistryContext) => {
         version?: string;
         includeInactive?: boolean;
     }) => Promise<{
-        name: string;
         type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+        name: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -72,8 +72,8 @@ export declare const createRegistry: (ctx: RegistryContext) => {
         expirationDate?: Date | null | undefined;
     }[]>;
     findConsentPolicyById: (policyId: string) => Promise<{
-        name: string;
         type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+        name: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -85,8 +85,8 @@ export declare const createRegistry: (ctx: RegistryContext) => {
         expirationDate?: Date | null | undefined;
     } | null>;
     findOrCreatePolicy: (type: import("./consent-policy").PolicyType) => Promise<{
-        name: string;
         type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+        name: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -98,9 +98,9 @@ export declare const createRegistry: (ctx: RegistryContext) => {
         expirationDate?: Date | null | undefined;
     }>;
     createConsentPurpose: (consentPurpose: Omit<import("./consent-purpose").ConsentPurpose, "id" | "createdAt" | "updatedAt"> & Partial<import("./consent-purpose").ConsentPurpose>, context?: import("../pkgs/types").GenericEndpointContext) => Promise<{
+        description: string;
         code: string;
         name: string;
-        description: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -110,9 +110,9 @@ export declare const createRegistry: (ctx: RegistryContext) => {
         legalBasis?: string | undefined;
     }>;
     findConsentPurposeByCode: (code: string) => Promise<{
+        description: string;
         code: string;
         name: string;
-        description: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;

package/dist/schema/create-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-registry.d.ts","sourceRoot":"","sources":["../../src/schema/create-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAWpD,eAAO,MAAM,cAAc,GAAI,KAAK,eAAe;;;;;;;;;;;iBAUmtE,CAAC;yBAA8B,CAAC;iBAAsB,CAAC;eAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA+jI,CAAC;eAAqB,CAAC;uBAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADr8M,CAAC"}
+{"version":3,"file":"create-registry.d.ts","sourceRoot":"","sources":["../../src/schema/create-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAWpD,eAAO,MAAM,cAAc,GAAI,KAAK,eAAe;;;;;;;;;;;iBAUmtE,CAAC;yBAA8B,CAAC;iBAAsB,CAAC;eAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAilH,CAAC;eAAqB,CAAC;uBAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADv9L,CAAC"}

package/dist/schema/definition.d.ts

@@ -112,9 +112,9 @@ export declare const getConsentTables: (options: C15TOptions) => {
             createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
             updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
         }, "strip", import("zod").ZodTypeAny, {
+            description: string;
             code: string;
             name: string;
-            description: string;
             id: string;
             createdAt: Date;
             updatedAt: Date;
@@ -123,9 +123,9 @@ export declare const getConsentTables: (options: C15TOptions) => {
             dataCategory?: string | undefined;
             legalBasis?: string | undefined;
         }, {
+            description: string;
             code: string;
             name: string;
-            description: string;
             id: string;
             createdAt?: Date | undefined;
             updatedAt?: Date | undefined;
@@ -203,8 +203,8 @@ export declare const getConsentTables: (options: C15TOptions) => {
             createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
             updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
         }, "strip", import("zod").ZodTypeAny, {
-            name: string;
             type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+            name: string;
             id: string;
             createdAt: Date;
             updatedAt: Date;
@@ -215,8 +215,8 @@ export declare const getConsentTables: (options: C15TOptions) => {
             contentHash: string;
             expirationDate?: Date | null | undefined;
         }, {
-            name: string;
             type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+            name: string;
             id: string;
             version: string;
             effectiveDate: Date;

package/dist/schema/index.cjs

@@ -1137,21 +1137,10 @@ function consentRegistry({ adapter, ...ctx }) {
     };
     return registry;
 }
-async function generatePolicyPlaceholder(name, date) {
+const external_node_crypto_namespaceObject = require("node:crypto");
+function generatePolicyPlaceholder(name, date) {
     const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
-    let contentHash;
-    try {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(content);
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-        contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
-    } catch (error) {
-        throw new error_class_DoubleTieError('Failed to generate policy content hash', {
-            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-            status: 500,
-            cause: error instanceof Error ? error : new Error(String(error))
-        });
-    }
+    const contentHash = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(content).digest('hex');
     return {
         content,
         contentHash
@@ -1211,53 +1200,44 @@ function policyRegistry({ adapter, ...ctx }) {
             });
             return policy ? validateEntityOutput('consentPolicy', policy, ctx.options) : null;
         },
-        findOrCreatePolicy: async (type)=>await adapter.transaction({
+        findOrCreatePolicy: async (type)=>adapter.transaction({
                 callback: async (txAdapter)=>{
-                    try {
-                        const now = new Date();
-                        const txRegistry = policyRegistry({
-                            adapter: txAdapter,
-                            ...ctx
-                        });
-                        const rawLatestPolicy = await txAdapter.findOne({
-                            model: 'consentPolicy',
-                            where: [
-                                {
-                                    field: 'isActive',
-                                    value: true
-                                },
-                                {
-                                    field: 'type',
-                                    value: type
-                                }
-                            ],
-                            sortBy: {
-                                field: 'effectiveDate',
-                                direction: 'desc'
+                    const now = new Date();
+                    const txRegistry = policyRegistry({
+                        adapter: txAdapter,
+                        ...ctx
+                    });
+                    const rawLatestPolicy = await txAdapter.findOne({
+                        model: 'consentPolicy',
+                        where: [
+                            {
+                                field: 'isActive',
+                                value: true
+                            },
+                            {
+                                field: 'type',
+                                value: type
                             }
-                        });
-                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                        if (latestPolicy) return latestPolicy;
-                        const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
-                        return txRegistry.createConsentPolicy({
-                            version: '1.0.0',
-                            type,
-                            name: type,
-                            effectiveDate: now,
-                            content: defaultContent,
-                            contentHash,
-                            isActive: true,
-                            updatedAt: now,
-                            expirationDate: null
-                        });
-                    } catch (error) {
-                        ctx.logger.error('Error in findOrCreatePolicy transaction:', error);
-                        throw new error_class_DoubleTieError('Failed to find or create policy', {
-                            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                            status: 500,
-                            cause: error instanceof Error ? error : new Error(String(error))
-                        });
-                    }
+                        ],
+                        sortBy: {
+                            field: 'effectiveDate',
+                            direction: 'desc'
+                        }
+                    });
+                    const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
+                    if (latestPolicy) return latestPolicy;
+                    const { content: defaultContent, contentHash } = generatePolicyPlaceholder(type, now);
+                    return txRegistry.createConsentPolicy({
+                        version: '1.0.0',
+                        type,
+                        name: type,
+                        effectiveDate: now,
+                        content: defaultContent,
+                        contentHash,
+                        isActive: true,
+                        updatedAt: now,
+                        expirationDate: null
+                    });
                 }
             })
     };

package/dist/schema/index.js

@@ -4,6 +4,7 @@ import "neverthrow";
 import * as __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__ from "@orpc/server";
 import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__ from "@opentelemetry/api";
 import * as __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__ from "@doubletie/logger";
+import * as __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__ from "node:crypto";
 const COMMON_TIMEZONES = {
     UTC: 'UTC',
     GMT: 'GMT',
@@ -1077,21 +1078,9 @@ function consentRegistry({ adapter, ...ctx }) {
     };
     return registry;
 }
-async function generatePolicyPlaceholder(name, date) {
+function generatePolicyPlaceholder(name, date) {
     const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
-    let contentHash;
-    try {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(content);
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-        contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
-    } catch (error) {
-        throw new error_class_DoubleTieError('Failed to generate policy content hash', {
-            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-            status: 500,
-            cause: error instanceof Error ? error : new Error(String(error))
-        });
-    }
+    const contentHash = (0, __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__.createHash)('sha256').update(content).digest('hex');
     return {
         content,
         contentHash
@@ -1151,53 +1140,44 @@ function policyRegistry({ adapter, ...ctx }) {
             });
             return policy ? validateEntityOutput('consentPolicy', policy, ctx.options) : null;
         },
-        findOrCreatePolicy: async (type)=>await adapter.transaction({
+        findOrCreatePolicy: async (type)=>adapter.transaction({
                 callback: async (txAdapter)=>{
-                    try {
-                        const now = new Date();
-                        const txRegistry = policyRegistry({
-                            adapter: txAdapter,
-                            ...ctx
-                        });
-                        const rawLatestPolicy = await txAdapter.findOne({
-                            model: 'consentPolicy',
-                            where: [
-                                {
-                                    field: 'isActive',
-                                    value: true
-                                },
-                                {
-                                    field: 'type',
-                                    value: type
-                                }
-                            ],
-                            sortBy: {
-                                field: 'effectiveDate',
-                                direction: 'desc'
+                    const now = new Date();
+                    const txRegistry = policyRegistry({
+                        adapter: txAdapter,
+                        ...ctx
+                    });
+                    const rawLatestPolicy = await txAdapter.findOne({
+                        model: 'consentPolicy',
+                        where: [
+                            {
+                                field: 'isActive',
+                                value: true
+                            },
+                            {
+                                field: 'type',
+                                value: type
                             }
-                        });
-                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                        if (latestPolicy) return latestPolicy;
-                        const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
-                        return txRegistry.createConsentPolicy({
-                            version: '1.0.0',
-                            type,
-                            name: type,
-                            effectiveDate: now,
-                            content: defaultContent,
-                            contentHash,
-                            isActive: true,
-                            updatedAt: now,
-                            expirationDate: null
-                        });
-                    } catch (error) {
-                        ctx.logger.error('Error in findOrCreatePolicy transaction:', error);
-                        throw new error_class_DoubleTieError('Failed to find or create policy', {
-                            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                            status: 500,
-                            cause: error instanceof Error ? error : new Error(String(error))
-                        });
-                    }
+                        ],
+                        sortBy: {
+                            field: 'effectiveDate',
+                            direction: 'desc'
+                        }
+                    });
+                    const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
+                    if (latestPolicy) return latestPolicy;
+                    const { content: defaultContent, contentHash } = generatePolicyPlaceholder(type, now);
+                    return txRegistry.createConsentPolicy({
+                        version: '1.0.0',
+                        type,
+                        name: type,
+                        effectiveDate: now,
+                        content: defaultContent,
+                        contentHash,
+                        isActive: true,
+                        updatedAt: now,
+                        expirationDate: null
+                    });
                 }
             })
     };

package/dist/schema/schemas.d.ts

@@ -90,8 +90,8 @@ export declare const schemas: {
         createdAt: z.ZodDefault<z.ZodDate>;
         updatedAt: z.ZodDefault<z.ZodDate>;
     }, "strip", z.ZodTypeAny, {
-        name: string;
         type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+        name: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -102,8 +102,8 @@ export declare const schemas: {
         contentHash: string;
         expirationDate?: Date | null | undefined;
     }, {
-        name: string;
         type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+        name: string;
         id: string;
         version: string;
         effectiveDate: Date;
@@ -126,9 +126,9 @@ export declare const schemas: {
         createdAt: z.ZodDefault<z.ZodDate>;
         updatedAt: z.ZodDefault<z.ZodDate>;
     }, "strip", z.ZodTypeAny, {
+        description: string;
         code: string;
         name: string;
-        description: string;
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -137,9 +137,9 @@ export declare const schemas: {
         dataCategory?: string | undefined;
         legalBasis?: string | undefined;
     }, {
+        description: string;
         code: string;
         name: string;
-        description: string;
         id: string;
         createdAt?: Date | undefined;
         updatedAt?: Date | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c15t/backend",
-  "version": "1.2.0-canary.13",
+  "version": "1.2.0-canary.2",
   "license": "GPL-3.0-only",
   "type": "module",
   "exports": {
@@ -19,11 +19,6 @@
       "import": "./dist/schema/index.js",
       "require": "./dist/schema/index.cjs"
     },
-    "./contracts": {
-      "types": "./dist/contracts/index.d.ts",
-      "import": "./dist/contracts.js",
-      "require": "./dist/contracts.cjs"
-    },
     "./pkgs/data-model/fields": {
       "types": "./dist/pkgs/data-model/fields/index.d.ts",
       "import": "./dist/pkgs/data-model/fields/index.js",
@@ -109,7 +104,6 @@
     "@types/node": "20.14.13",
     "@types/pg": "8.11.6",
     "kysely-pglite": "^0.6.1",
-    "msw": "^2.7.6",
     "typescript": "^5.8.3",
     "vitest": "^3.1.1",
     "@c15t/typescript-config": "0.0.1-beta.1",
@@ -122,7 +116,7 @@
     "build": "rslib build",
     "check-types": "tsc --noEmit",
     "dev": "rslib build --watch",
-    "fmt": "pnpm biome format --write . && pnpm biome check --formatter-enabled=false --linter-enabled=false --organize-imports-enabled=true --write",
+    "fmt": "pnpm biome format --write . && biome check --formatter-enabled=false --linter-enabled=false --organize-imports-enabled=true --write",
     "knip": "knip",
     "lint": "pnpm biome lint ./src",
     "start": "node dist/server.cjs",

package/rslib.config.ts

@@ -62,7 +62,6 @@ export default defineConfig({
 		entry: {
 			core: ['./src/core.ts'],
 			router: ['./src/router.ts'],
-			contracts: ['./src/contracts/index.ts'],
 			'schema/index': ['./src/schema/index.ts'],
 			'pkgs/data-model/fields/index': ['./src/pkgs/data-model/fields/index.ts'],
 			'pkgs/data-model/index': ['./src/pkgs/data-model/index.ts'],

package/src/contracts/consent/post.contract.ts

@@ -6,7 +6,12 @@ import { PolicyTypeSchema } from '~/schema';
 const baseConsentSchema = z.object({
 	subjectId: z.string().optional(),
 	externalSubjectId: z.string().optional(),
-	domain: z.string(),
+	domain: z
+		.string()
+		.regex(
+			/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i,
+			'invalid domain'
+		),
 	type: PolicyTypeSchema,
 	metadata: z.record(z.unknown()).optional(),
 });

package/src/contracts/index.ts

@@ -12,8 +12,6 @@ const config = {
 	meta: metaContracts,
 };
 
-export { config as contracts };
-
 export const os = implement(config);
 
 export type ContractsOutputs = InferContractRouterOutputs<typeof config>;