@dma-sdk/hubspot 1.0.1

package/dist/constants/types.d.ts

@@ -0,0 +1,23 @@
+export declare const hsDataTypes: {
+    string: string;
+    number: string;
+    boolean: string;
+    date: string;
+    datetime: string;
+    single_select: string;
+    multiple_select: string;
+    checkbox: string;
+    calculation: string;
+    phone_number: string;
+    user: string;
+    file: string;
+    score: string;
+    currency: string;
+    rich_text: string;
+    owner: string;
+    location: string;
+    json: string;
+    percentage: string;
+    ip_address: string;
+    video: string;
+};

package/dist/constants/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hsDataTypes = void 0;
+exports.hsDataTypes = {
+    string: "string",
+    number: "number",
+    boolean: "bool",
+    date: "date",
+    datetime: "datetime",
+    single_select: "enumeration",
+    multiple_select: "enumeration",
+    checkbox: "bool",
+    calculation: "calculation_equation",
+    phone_number: "phone_number",
+    user: "hubspot_user",
+    file: "file",
+    score: "score",
+    currency: "currency",
+    rich_text: "rich_text",
+    owner: "owner",
+    location: "location",
+    json: "json",
+    percentage: "number",
+    ip_address: "ip_address",
+    video: "video"
+};

package/dist/hubspot-service.d.ts

@@ -0,0 +1,88 @@
+import { HubspotUser } from './interfaces/user';
+import { Configuration, Filter } from '@hubspot/api-client/lib/codegen/crm/objects';
+import { SimplePublicObjectInputForCreate } from '@hubspot/api-client/lib/codegen/crm/objects/taxes/models/all';
+import { SimplePublicObject } from '@hubspot/api-client/lib/codegen/crm/objects/tasks/models/all';
+import { LabelsBetweenObjectPair } from '@hubspot/api-client/lib/codegen/crm/associations/v4';
+import { TokenResponseIF } from '@hubspot/api-client/lib/codegen/oauth';
+import { TokenResponse } from './interfaces/token';
+import { CollectionResponsePropertyNoPaging, PropertyCreate, PropertyGroup, PropertyGroupCreate } from '@hubspot/api-client/lib/codegen/crm/properties';
+import { HubspotSignatureData } from './types/auth/hs-signature-data';
+export declare class HubspotService {
+    static HS_BASE_URL: string;
+    static readonly hubspotObjectType: {
+        contacts: string;
+        notes: string;
+    };
+    static readonly hubspotPropertyTypes: {
+        string: string;
+        number: string;
+        boolean: string;
+        date: string;
+        datetime: string;
+        single_select: string;
+        multiple_select: string;
+        checkbox: string;
+        calculation: string;
+        phone_number: string;
+        user: string;
+        file: string;
+        score: string;
+        currency: string;
+        rich_text: string;
+        owner: string;
+        location: string;
+        json: string;
+        percentage: string;
+        ip_address: string;
+        video: string;
+    };
+    private client;
+    private hsRedirectUriOauth;
+    private hsClientId;
+    private hsClientSecret;
+    private typeConvert;
+    private apiMethods;
+    constructor(hsRedirectUriOauth: string, hsClientId: string, hsClientSecret: string);
+    exchangeCodeForTokens(params: {
+        code: string;
+    }): Promise<TokenResponseIF>;
+    getUserInfoByToken(accessToken: string): Promise<HubspotUser>;
+    verifyFetchReqSignature(params: {
+        version: string;
+        data: HubspotSignatureData;
+    }): Promise<boolean>;
+    refreshAccessToken(refreshToken: string): Promise<TokenResponse>;
+    listObjectProperties(params: {
+        objectType: string;
+        types?: string[];
+        accessToken?: string;
+    }): Promise<CollectionResponsePropertyNoPaging>;
+    listObjects(objectType: string, filters: Filter[], accessToken: string): Promise<SimplePublicObject[] | null>;
+    createObject(objectType: string, properties: SimplePublicObjectInputForCreate, accessToken: string): Promise<SimplePublicObject | {
+        id: string;
+    }>;
+    getObject(objectType: string, objectId: string, accessToken: string): Promise<SimplePublicObject>;
+    getObjectProps(objectType: string, objectId: string, props: string[], // nome delle props da restituire
+    accessToken: string): Promise<SimplePublicObject>;
+    getObjectWithPropsType(objectType: string, objectId: string, accessToken: string, types?: string[]): Promise<SimplePublicObject & {
+        propertiesWithTypes: {
+            [key: string]: {
+                type: string;
+                label: string;
+                value: string | null;
+            };
+        };
+    }>;
+    updateObject(objectType: string, objectId: string, properties: {
+        [key: string]: string;
+    }, accessToken: string, options?: Configuration): Promise<SimplePublicObject>;
+    associateObjects(objectTypeFirst: string, objectTypeSecond: string, objectIdFirst: string, objectIdSecond: string, accessToken: string): Promise<LabelsBetweenObjectPair>;
+    createObjectProperties(objectType: string, properties: PropertyCreate[], accessToken: string): Promise<any>;
+    createPropertyGroup(objectType: string, group: PropertyGroupCreate, accessToken: string): Promise<PropertyGroup>;
+    convertPropertyValues(properties: {
+        [key: string]: any;
+    }, convertionMap: {
+        [propertyName: string]: PropertyCreate;
+    }): Record<string, any>;
+    private fetchApi;
+}

package/dist/hubspot-service.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubspotService = void 0;
+const api_client_1 = require("@hubspot/api-client");
+const type_converter_1 = require("./utils/type-converter");
+const types_1 = require("./constants/types");
+const api_client_2 = require("@hubspot/api-client");
+const fetch_1 = require("@dma-sdk/utils/src/fetch");
+// Per ogni metodo che viene creato, è fondamentale che
+// il client venga inizializzato con il token di accesso
+// altrimenti non funzionerà correttamente.
+class HubspotService {
+    constructor(hsRedirectUriOauth, hsClientId, hsClientSecret) {
+        this.apiMethods = {
+            getUserInfoByToken: '/oauth/v1/access-tokens',
+            refreshToken: '/oauth/v1/token',
+            createObjectProperties: '/crm/v3/properties/{objectType}/batch/create',
+        };
+        ;
+        (this.hsRedirectUriOauth = hsRedirectUriOauth),
+            (this.hsClientId = hsClientId),
+            (this.hsClientSecret = hsClientSecret);
+        this.typeConvert = type_converter_1.typeConverter;
+        this.client = new api_client_1.Client();
+    }
+    async exchangeCodeForTokens(params) {
+        return await this.client.oauth.tokensApi.create('authorization_code', params.code, this.hsRedirectUriOauth, this.hsClientId, this.hsClientSecret);
+    }
+    async getUserInfoByToken(accessToken) {
+        const response = await this.client.apiRequest({
+            method: 'GET',
+            path: `${this.apiMethods.getUserInfoByToken}/${accessToken}`,
+        });
+        const jsonBody = await response.json();
+        const userAttributes = {
+            token: jsonBody.token,
+            user: jsonBody.user,
+            hubDomain: jsonBody.hub_domain,
+            scopes: jsonBody.scopes,
+            hubId: jsonBody.hub_id,
+            appId: jsonBody.app_id,
+            expiresIn: jsonBody.expires_in,
+            userId: jsonBody.user_id,
+            tokenType: jsonBody.token_type,
+            signedAccessToken: jsonBody.signed_access_token,
+        };
+        return userAttributes;
+    }
+    async verifyFetchReqSignature(params) {
+        const queryString = (params.data.qs && Object.keys(params.data.qs).length > 0) ? `?${new URLSearchParams(params.data.qs).toString()}` : '';
+        const url = decodeURIComponent(`https://${params.data.domainName}${params.data.path}${queryString}`);
+        return api_client_2.Signature.isValid({
+            method: params.data.httpMethod,
+            signatureVersion: params.version,
+            signature: params.data.signature,
+            requestBody: params.data.body,
+            timestamp: params.data.timestamp,
+            url,
+            clientSecret: this.hsClientSecret,
+        });
+    }
+    async refreshAccessToken(refreshToken) {
+        const token = await this.client.oauth.tokensApi.create('refresh_token', undefined, this.hsRedirectUriOauth, this.hsClientId, this.hsClientSecret, refreshToken);
+        return {
+            accessToken: token.accessToken,
+            expiresIn: token.expiresIn,
+            refreshToken: token.refreshToken,
+            tokenType: token.tokenType,
+        };
+    }
+    async listObjectProperties(params) {
+        const { objectType, types, accessToken } = params;
+        if (accessToken)
+            this.client.setAccessToken(accessToken);
+        const props = await this.client.crm.properties.coreApi.getAll(objectType);
+        if (!types)
+            return props;
+        return { results: props.results.filter((prop) => types.includes(prop.fieldType) || types.includes(prop.type)) };
+    }
+    async listObjects(objectType, filters, accessToken) {
+        this.client.setAccessToken(accessToken);
+        const response = await this.client.crm.objects.searchApi.doSearch(objectType, {
+            filterGroups: [
+                {
+                    filters: filters,
+                },
+            ],
+        });
+        return response.results || null;
+    }
+    async createObject(objectType, properties, accessToken) {
+        this.client.setAccessToken(accessToken);
+        const response = await this.client.crm.objects.basicApi.create(objectType, properties);
+        return response;
+    }
+    async getObject(objectType, objectId, accessToken) {
+        this.client.setAccessToken(accessToken);
+        return await this.client.crm.objects.basicApi.getById(objectType, objectId);
+    }
+    async getObjectProps(objectType, objectId, props, // nome delle props da restituire
+    accessToken) {
+        this.client.setAccessToken(accessToken);
+        return await this.client.crm.objects.basicApi.getById(objectType, objectId, props);
+    }
+    async getObjectWithPropsType(objectType, objectId, accessToken, types) {
+        this.client.setAccessToken(accessToken);
+        const props = await this.listObjectProperties({ objectType, types });
+        const data = await this.getObjectProps(objectType, objectId, props.results.map((prop) => prop.name), accessToken);
+        let formattedProp = {};
+        props.results.forEach((property) => {
+            if (!data.properties[property.name]) {
+                return;
+            }
+            formattedProp[property.name] = {
+                type: property.fieldType,
+                label: property.label,
+                value: data.properties[property.name]
+            };
+        });
+        return {
+            ...data,
+            propertiesWithTypes: formattedProp
+        };
+    }
+    async updateObject(objectType, objectId, properties, accessToken, options) {
+        this.client.setAccessToken(accessToken);
+        const response = await this.client.crm.objects.basicApi.update(objectType, objectId, {
+            properties: {
+                ...properties
+            }
+        });
+        return response;
+    }
+    async associateObjects(objectTypeFirst, objectTypeSecond, objectIdFirst, objectIdSecond, accessToken) {
+        this.client.setAccessToken(accessToken);
+        const response = await this.client.crm.associations.v4.basicApi.create(objectTypeFirst, objectIdFirst, objectTypeSecond, objectIdSecond, []);
+        return response;
+    }
+    async createObjectProperties(objectType, properties, accessToken) {
+        const options = {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                inputs: properties
+            })
+        };
+        const response = await this.fetchApi(this.apiMethods.createObjectProperties.replace('{objectType}', objectType), options);
+        return await response.json();
+    }
+    async createPropertyGroup(objectType, group, accessToken) {
+        this.client.setAccessToken(accessToken);
+        return await this.client.crm.properties.groupsApi.create(objectType, group);
+    }
+    convertPropertyValues(properties, convertionMap) {
+        let convertedProps = {};
+        Object.entries(properties).forEach(([key, value]) => {
+            var _a;
+            if (value === undefined)
+                return;
+            const convertionFunc = this.typeConvert[(_a = convertionMap[key]) === null || _a === void 0 ? void 0 : _a.type];
+            if (convertionFunc === undefined) {
+                convertedProps[key] = value;
+                return;
+            }
+            convertedProps[key] = convertionFunc(value);
+        });
+        return convertedProps;
+    }
+    async fetchApi(endpoint, options, queryParams) {
+        return await (0, fetch_1.fetchApi)(HubspotService.HS_BASE_URL, endpoint, options, queryParams);
+    }
+}
+exports.HubspotService = HubspotService;
+HubspotService.HS_BASE_URL = 'https://api.hubapi.com';
+HubspotService.hubspotObjectType = {
+    contacts: 'contacts',
+    notes: 'notes',
+};
+HubspotService.hubspotPropertyTypes = types_1.hsDataTypes;

package/dist/interfaces/hubspot-type-converter.d.ts

@@ -0,0 +1,3 @@
+export interface HubspotTypeConverter {
+    [key: string]: (data: any) => any;
+}

package/dist/interfaces/hubspot-type-converter.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/dist/interfaces/token.d.ts

@@ -0,0 +1,8 @@
+export interface TokenResponse {
+    accessToken: string;
+    expiresIn: number;
+    hubId?: string;
+    refreshToken: string;
+    scopes?: string;
+    tokenType: string;
+}

package/dist/interfaces/token.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/user.d.ts

@@ -0,0 +1,29 @@
+export interface HubspotUser {
+    token: string;
+    user: string;
+    hubDomain: string;
+    scopes: string[];
+    hubId: string;
+    appId: number;
+    expiresIn: number;
+    userId: number;
+    tokenType: string;
+    signedAccessToken: string;
+}
+export interface HubspotFetchUser {
+    hubId: string;
+    email: string;
+    userId: number;
+}
+export interface ContextHubspotUser {
+    token: string;
+    user: string;
+    hubDomain: string;
+    scopes: string[];
+    hubId: string;
+    appId: number;
+    expiresIn: number;
+    userId: number;
+    tokenType: string;
+    signedAccessToken: string;
+}

package/dist/interfaces/user.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/auth/hs-signature-data.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const hubspotSignatureDataSchema: z.ZodObject<{
+    signature: z.ZodString;
+    timestamp: z.ZodCoercedNumber<unknown>;
+    domainName: z.ZodString;
+    path: z.ZodString;
+    httpMethod: z.ZodString;
+    body: z.ZodString;
+    qs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotSignatureData = z.infer<typeof hubspotSignatureDataSchema>;

package/dist/types/auth/hs-signature-data.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hubspotSignatureDataSchema = void 0;
+const zod_1 = require("zod");
+exports.hubspotSignatureDataSchema = zod_1.z.object({
+    signature: zod_1.z.string(),
+    timestamp: zod_1.z.coerce.number(),
+    domainName: zod_1.z.string(),
+    path: zod_1.z.string(),
+    httpMethod: zod_1.z.string(),
+    body: zod_1.z.string(),
+    qs: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+});

package/dist/types/object/contact.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const contactSchema: z.ZodObject<{
+    createdAt: z.ZodDate;
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export declare const contactWithPropsTypeSchema: z.ZodObject<{
+    id: z.ZodString;
+    propertiesWithTypes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export type ContactGet = z.infer<typeof contactSchema>;
+export type ContactWithPropsTypeGet = z.infer<typeof contactWithPropsTypeSchema>;

package/dist/types/object/contact.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contactWithPropsTypeSchema = exports.contactSchema = void 0;
+const zod_1 = require("zod");
+exports.contactSchema = zod_1.z.object({
+    createdAt: zod_1.z.date(),
+    id: zod_1.z.string(),
+    properties: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+    updatedAt: zod_1.z.date().optional(),
+});
+exports.contactWithPropsTypeSchema = exports.contactSchema
+    .extend({
+    propertiesWithTypes: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        type: zod_1.z.string(),
+        label: zod_1.z.string(),
+        value: zod_1.z.string().nullable()
+    })),
+})
+    .omit({
+    properties: true
+});

package/dist/utils/type-converter.d.ts

@@ -0,0 +1,2 @@
+import { HubspotTypeConverter } from "../interfaces/hubspot-type-converter";
+export declare const typeConverter: HubspotTypeConverter;

package/dist/utils/type-converter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeConverter = void 0;
+const types_1 = require("../constants/types");
+exports.typeConverter = {
+    [types_1.hsDataTypes.date]: (data) => {
+        return (new Date(data)).setUTCHours(0, 0, 0, 0);
+    },
+    [types_1.hsDataTypes.datetime]: (data) => {
+        return new Date(data).getTime();
+    },
+    [types_1.hsDataTypes.number]: (data) => {
+        return (typeof data === "number") ? data : parseFloat(data);
+    }
+};

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@dma-sdk/hubspot",
+  "version": "1.0.1",
+  "description": "DMA SDK – Hubspot service",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "@dma-sdk/utils": "^1.0.0",
+    "@hubspot/api-client": "^13.4.0",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "typescript": "^5.2.0"
+  }
+}

package/src/constants/types.ts

@@ -0,0 +1,23 @@
+export const hsDataTypes = {
+        string: "string", 
+        number: "number",
+        boolean: "bool",
+        date: "date",
+        datetime: "datetime",
+        single_select: "enumeration",
+        multiple_select: "enumeration",
+        checkbox: "bool",
+        calculation: "calculation_equation",
+        phone_number: "phone_number", 
+        user: "hubspot_user", 
+        file: "file",
+        score: "score",
+        currency: "currency",
+        rich_text: "rich_text",
+        owner: "owner",
+        location: "location",
+        json: "json",
+        percentage: "number",
+        ip_address: "ip_address",
+        video: "video" 
+    };

package/src/hubspot-service.ts

@@ -0,0 +1,307 @@
+import { Client as HubspotClient } from '@hubspot/api-client'
+import { HubspotUser } from './interfaces/user'
+import { Configuration, Filter } from '@hubspot/api-client/lib/codegen/crm/objects'
+import { SimplePublicObjectInputForCreate } from '@hubspot/api-client/lib/codegen/crm/objects/taxes/models/all'
+import { SimplePublicObject } from '@hubspot/api-client/lib/codegen/crm/objects/tasks/models/all'
+import { LabelsBetweenObjectPair } from '@hubspot/api-client/lib/codegen/crm/associations/v4'
+import { TokenResponseIF } from '@hubspot/api-client/lib/codegen/oauth'
+import { typeConverter } from './utils/type-converter'
+import { HubspotTypeConverter } from './interfaces/hubspot-type-converter'
+import { hsDataTypes } from './constants/types'
+import { Signature } from '@hubspot/api-client'
+import { TokenResponse } from './interfaces/token'
+import { CollectionResponsePropertyNoPaging, PropertyCreate, PropertyGroup, PropertyGroupCreate } from '@hubspot/api-client/lib/codegen/crm/properties'
+import { HubspotSignatureData } from './types/auth/hs-signature-data'
+import { fetchApi } from '@dma-sdk/utils/src/fetch'
+
+// Per ogni metodo che viene creato, è fondamentale che
+// il client venga inizializzato con il token di accesso
+// altrimenti non funzionerà correttamente.
+
+export class HubspotService {
+    public static HS_BASE_URL = 'https://api.hubapi.com'
+    public static readonly hubspotObjectType = {
+        contacts: 'contacts',
+        notes: 'notes',
+    }
+    public static readonly hubspotPropertyTypes = hsDataTypes
+
+    private client: HubspotClient
+    private hsRedirectUriOauth: string
+    private hsClientId: string
+    private hsClientSecret: string
+    private typeConvert: HubspotTypeConverter
+
+    private apiMethods = {
+        getUserInfoByToken: '/oauth/v1/access-tokens',
+        refreshToken: '/oauth/v1/token',
+        createObjectProperties: '/crm/v3/properties/{objectType}/batch/create',
+    }
+
+
+    constructor(hsRedirectUriOauth: string, hsClientId: string, hsClientSecret: string) {
+        ;(this.hsRedirectUriOauth = hsRedirectUriOauth),
+            (this.hsClientId = hsClientId),
+            (this.hsClientSecret = hsClientSecret)
+        this.typeConvert = typeConverter
+
+        this.client = new HubspotClient()
+    }
+
+    async exchangeCodeForTokens(params: { code: string }): Promise<TokenResponseIF> {
+        return await this.client.oauth.tokensApi.create(
+            'authorization_code',
+            params.code,
+            this.hsRedirectUriOauth,
+            this.hsClientId,
+            this.hsClientSecret
+        )
+    }
+
+    async getUserInfoByToken(accessToken: string): Promise<HubspotUser> {
+        const response = await this.client.apiRequest({
+            method: 'GET',
+            path: `${this.apiMethods.getUserInfoByToken}/${accessToken}`,
+        })
+
+        const jsonBody = await response.json()
+        const userAttributes = {
+            token: jsonBody.token,
+            user: jsonBody.user,
+            hubDomain: jsonBody.hub_domain,
+            scopes: jsonBody.scopes,
+            hubId: jsonBody.hub_id,
+            appId: jsonBody.app_id,
+            expiresIn: jsonBody.expires_in,
+            userId: jsonBody.user_id,
+            tokenType: jsonBody.token_type,
+            signedAccessToken: jsonBody.signed_access_token,
+        }
+
+        return userAttributes
+    }
+
+    async verifyFetchReqSignature(params: { version: string, data: HubspotSignatureData }): Promise<boolean> {
+        const queryString: string = (params.data.qs && Object.keys(params.data.qs).length > 0) ? `?${new URLSearchParams(params.data.qs).toString()}` : ''
+        const url: string = decodeURIComponent(`https://${params.data.domainName}${params.data.path}${queryString}`)        
+
+        return Signature.isValid({
+            method: params.data.httpMethod,
+            signatureVersion: params.version,
+            signature: params.data.signature,
+            requestBody: params.data.body,
+            timestamp: params.data.timestamp,
+            url,
+            clientSecret: this.hsClientSecret,
+        })
+    }
+
+    async refreshAccessToken(refreshToken: string): Promise<TokenResponse> {
+        const token = await this.client.oauth.tokensApi.create(
+            'refresh_token',
+            undefined,
+            this.hsRedirectUriOauth,
+            this.hsClientId,
+            this.hsClientSecret,
+            refreshToken
+        )
+
+        return {
+            accessToken: token.accessToken,
+            expiresIn: token.expiresIn,
+            refreshToken: token.refreshToken,
+            tokenType: token.tokenType,
+        }
+    }
+
+
+    async listObjectProperties(params: {
+        objectType: string, 
+        types?: string[], // tipi di props da restituire
+        accessToken?: string
+    }): Promise<CollectionResponsePropertyNoPaging> {
+        const { objectType, types, accessToken } = params
+        if(accessToken) this.client.setAccessToken(accessToken)
+        const props = await this.client.crm.properties.coreApi.getAll(objectType);
+
+        if(!types) return props
+
+        return { results: props.results.filter((prop) => types.includes(prop.fieldType) || types.includes(prop.type)) }
+    }
+
+    async listObjects(
+        objectType: string,
+        filters: Filter[],
+        accessToken: string
+    ): Promise<SimplePublicObject[] | null> {
+        this.client.setAccessToken(accessToken)
+        const response = await this.client.crm.objects.searchApi.doSearch(objectType, {
+            filterGroups: [
+                {
+                    filters: filters,
+                },
+            ],
+        })
+
+        return response.results || null
+    }
+
+    async createObject(
+        objectType: string,
+        properties: SimplePublicObjectInputForCreate,
+        accessToken: string
+    ): Promise<SimplePublicObject | { id: string }> {
+        this.client.setAccessToken(accessToken)
+        const response = await this.client.crm.objects.basicApi.create(objectType, properties)
+
+        return response
+    }
+
+    async getObject(
+        objectType: string, 
+        objectId: string, 
+        accessToken: string
+    ): Promise<SimplePublicObject> {
+        this.client.setAccessToken(accessToken)
+        return await this.client.crm.objects.basicApi.getById(
+            objectType,
+            objectId
+        );
+    }
+
+    async getObjectProps(
+        objectType: string, 
+        objectId: string,
+        props: string[], // nome delle props da restituire
+        accessToken: string
+    ): Promise<SimplePublicObject> {
+        this.client.setAccessToken(accessToken)
+        return await this.client.crm.objects.basicApi.getById(
+            objectType,
+            objectId,
+            props
+        );
+    }
+
+    async getObjectWithPropsType(
+        objectType: string, 
+        objectId: string, 
+        accessToken: string,
+        types?: string[]
+    ): Promise<SimplePublicObject & { propertiesWithTypes: { [key: string]: { type: string, label: string, value: string | null } }}> {
+        this.client.setAccessToken(accessToken)
+        const props = await this.listObjectProperties({ objectType, types })
+        const data = await this.getObjectProps(
+            objectType,
+            objectId,
+            props.results.map((prop) => prop.name),
+            accessToken
+        );
+
+        
+        let formattedProp: { [key: string]: { type: string, label: string, value: string | null } } = {}
+        props.results.forEach((property) => {
+            if(!data.properties[property.name]){
+                return 
+            }
+
+            formattedProp[property.name] = {
+                type: property.fieldType,
+                label: property.label,
+                value: data.properties[property.name]
+            }
+        })
+
+        return {
+            ...data,
+            propertiesWithTypes: formattedProp
+        }
+    }
+
+    async updateObject(
+        objectType: string,
+        objectId: string,
+        properties: {
+            [key: string]: string;
+        },
+        accessToken: string,
+        options?: Configuration
+    ): Promise<SimplePublicObject> {
+        this.client.setAccessToken(accessToken)
+        const response = await this.client.crm.objects.basicApi.update(objectType, objectId, {
+            properties: {
+                ...properties
+            }
+        })
+
+        return response
+    }
+
+    async associateObjects(
+        objectTypeFirst: string,
+        objectTypeSecond: string,
+        objectIdFirst: string,
+        objectIdSecond: string,
+        accessToken: string
+    ): Promise<LabelsBetweenObjectPair> {
+        this.client.setAccessToken(accessToken)
+        const response = await this.client.crm.associations.v4.basicApi.create(
+            objectTypeFirst,
+            objectIdFirst,
+            objectTypeSecond,
+            objectIdSecond,
+            []
+        )
+
+        return response
+    }
+
+    async createObjectProperties(
+        objectType: string, 
+        properties: PropertyCreate[],
+        accessToken: string
+    ) {
+        const options = {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`, 
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                inputs: properties
+            })
+        };
+
+        const response = await this.fetchApi(this.apiMethods.createObjectProperties.replace('{objectType}', objectType), options)
+        return await response.json()
+    }
+
+    async createPropertyGroup(
+        objectType: string, 
+        group: PropertyGroupCreate,
+        accessToken: string
+    ): Promise<PropertyGroup> {
+        this.client.setAccessToken(accessToken)
+        return await this.client.crm.properties.groupsApi.create(objectType, group);
+    }
+
+    public convertPropertyValues(properties: { [key: string]: any }, convertionMap: { [propertyName: string]: PropertyCreate }) {
+        let convertedProps: Record<string, any> = {}
+        Object.entries(properties).forEach(([key, value]) => {
+            if(value === undefined) return
+            const convertionFunc = this.typeConvert[convertionMap[key]?.type]
+            if(convertionFunc === undefined) {
+                convertedProps[key] = value
+                return
+            }
+            convertedProps[key] = convertionFunc(value)
+        })
+
+        
+        return convertedProps
+    }
+    
+    private async fetchApi(endpoint: string, options: {}, queryParams?: {}): Promise<any> {
+        return await fetchApi(HubspotService.HS_BASE_URL, endpoint, options, queryParams)
+    }
+}

package/src/interfaces/hubspot-type-converter.ts

@@ -0,0 +1,4 @@
+
+export interface HubspotTypeConverter { 
+    [key: string]: (data: any) => any
+};

package/src/interfaces/token.ts

@@ -0,0 +1,8 @@
+export interface TokenResponse {
+    accessToken: string,
+    expiresIn: number,
+    hubId?: string,
+    refreshToken: string,
+    scopes?: string,
+    tokenType: string 
+}

package/src/interfaces/user.ts

@@ -0,0 +1,34 @@
+export interface HubspotUser {
+    token: string;
+    user: string;
+    hubDomain: string;
+    scopes: string[];
+    hubId: string;
+    appId: number;
+    expiresIn: number;
+    userId: number;
+    tokenType: string;
+    signedAccessToken: string;
+}
+
+
+export interface HubspotFetchUser {
+    hubId: string,
+    email: string,
+    userId: number
+}
+
+
+export interface ContextHubspotUser {
+    token: string;
+    user: string;
+    hubDomain: string;
+    scopes: string[];
+    hubId: string;
+    appId: number;
+    expiresIn: number;
+    userId: number;
+    tokenType: string;
+    signedAccessToken: string;
+}
+

package/src/types/auth/hs-signature-data.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+export const hubspotSignatureDataSchema = z.object({
+    signature: z.string(),
+    timestamp: z.coerce.number(),
+    domainName: z.string(),
+    path: z.string(),
+    httpMethod: z.string(),
+    body: z.string(),
+    qs: z.record(z.string(), z.string()).optional(),
+})
+
+export type HubspotSignatureData = z.infer<typeof hubspotSignatureDataSchema>

package/src/types/object/contact.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod'
+
+export const contactSchema = z.object({
+    createdAt: z.date(),
+    id: z.string(),
+    properties: z.record(z.string(), z.any()),
+    updatedAt: z.date().optional(),
+});
+
+
+export const contactWithPropsTypeSchema = contactSchema
+    .extend({
+        propertiesWithTypes: z.record(z.string(), z.object({
+            type: z.string(), 
+            label: z.string(), 
+            value: z.string().nullable()
+        })),
+    })
+    .omit({
+        properties: true
+    });
+
+
+export type ContactGet = z.infer<typeof contactSchema>
+export type ContactWithPropsTypeGet = z.infer<typeof contactWithPropsTypeSchema>

package/src/utils/type-converter.ts

@@ -0,0 +1,18 @@
+import { hsDataTypes } from "../constants/types";
+import { HubspotTypeConverter } from "../interfaces/hubspot-type-converter";
+import { string } from "zod";
+
+export const typeConverter: HubspotTypeConverter = {
+    [hsDataTypes.date]: 
+        (data: string) => {
+            return (new Date(data)).setUTCHours(0, 0, 0, 0);
+        },
+    [hsDataTypes.datetime]: 
+        (data: string) => {
+            return new Date(data).getTime();
+        },
+    [hsDataTypes.number]: 
+        (data: string | number) => {
+            return (typeof data === "number") ? data : parseFloat(data);
+        }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "CommonJS",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": [ "src" ]
+}