@adobe/acc-js-sdk 1.1.41 → 1.1.43

package/docs/_config.yml

@@ -34,6 +34,11 @@ github_username:  mkiki
 plugins:
   - jekyll-feed
 
+collections:
+  posts:
+    output: true
+
+
 # Exclude from processing.
 # The following items will not be processed, by default.
 # Any item listed under the `exclude:` key here will be automatically added to

package/docs/_posts/2022-10-14-welcome.html

@@ -1,7 +1,6 @@
 ---
 layout: post
 title:  "Welcome to the ACC JS SDK"
-date:   2022-10-14 09:06:57 +0200
 author: Alexandre Morin
 categories: "SDK Update"
 excerpt: Some ideas about how to use the SDK and a short example illustrating how to build a REST proxy lambda function

package/docs/_posts/2023-12-08-manipulateSchemas.html

@@ -0,0 +1,364 @@
+---
+layout: post
+title:  "Manipulating schemas"
+author: Alexandre Morin
+tags: schemas soap
+excerpt: Sequence of APIs to discover and create a FDA schema
+---
+
+
+<p>
+  This article will illustrate how to use APIs to create and manipulate schemas
+</p>
+
+<h1>Schemas</h1>
+
+<p>
+  There are 3 types of schemas in Campaign
+  <ul>
+    <li>Source schemas (xtk:srcSchema)</li>
+    <li>Schemas (xtk:schema)</li>
+    <li>SQL schemas (xtk:sqlSchema)</li>
+  </ul>
+</p>
+
+<p>
+  Users normally only create source schemas. Those are then "compiled" into schemas and SQL schemas.
+  The compilation process (called "build schemas") can take several seconds and is performed via an API call.
+  This means that the <b>xtk:builder#BuildSchema</b> (or similar API) must be called after schemas are 
+  modified or created, to ensure overall consistency.
+</p>
+
+<p> 
+  Once source schemas are created and compiled, you will usually use schemas and not source schemas because
+  source schemas are just the various elements that build up the final schemas. You will probably never need
+  to use sql schemas directly. They are used internally to map schemas to SQL tables.
+</p>
+<p>
+  Of course you can read and use source schemas as well but this is usually limited to schema authoring 
+  use cases. 
+</p>
+
+<table>
+  <thead>
+    <tr><th>Attribute/Method</th><th>Description</th></tr>
+  </thead>
+  <tbody>
+    <tr><td>Create or modify</td><td>Use source schemas and BuildSchema API</td></tr>
+    <tr><td>Delete</td><td></td></tr>
+    <tr><td>Use</td><td>Use schemas</td></tr>
+  </tbody>
+</table>
+
+
+<h1>Reading schemas</h1>
+
+<h2>Get a schema as a JSON object</h2>
+<p>
+  The simplest way to read a schema is to use the <b>getSchema</b> SDK APIs which also provide client-side caching.
+</p>
+
+<p>
+  The <b>client.getSchema()</b> API returns a JSON or XML object representing the (compiled) schema requested.
+  See the <a href="{{ site.baseurl }}/xtkSchema.html">Schema API</a> page for more details.
+</p>
+
+<pre class="code">
+const schema = await client.getSchema("nms:recipient");
+console.log(JSON.stringify(schema));
+</pre>
+
+<h2>Get a schema as a convenient JavaScript object</h2>
+<p>
+  The <b>application.getSchema()</b> API is built on top of the previous one and returns a schema object which
+  is more convenient to use that a raw JSON object. See the <a href="{{ site.baseurl }}/application.html">Application</a> object for more details.
+</p>
+
+<pre class="code">
+const schema = await client.application.getSchema("nms:recipient");
+</pre>
+  
+<h2>List schemas using a query</h2>
+<p>
+  It is also possible to use the <a href="{{ site.baseurl }}/xtkQueryDef.html">QueryDef</a> API to read schemas and source schemas.
+</p>
+<p>
+  Let's first get the list of source schemas in the custom namespace "cus". The following will return then
+  names and labels of 10 source schemas in the cus namespace.
+</p>
+
+<pre class="code">
+
+const queryDef = {
+  schema: "xtk:srcSchema",
+  operation: "select",
+  lineCount: 10,
+  select: {
+      node: [
+          { expr: "@name" },
+          { expr: "@namespace" },
+          { expr: "@label" }
+      ]
+  },
+  where: {
+    condition: [
+        { expr:`@namespace = 'cus'` }
+    ]
+  }
+};
+const query = client.NLWS.xtkQueryDef.create(queryDef);
+const srcSchemas = await query.executeQuery();
+</pre>
+
+<p>
+  To return schemas instead of source schemas, use "xtk:schema" instead of "xtk:srcSchema" in the QueryDef.
+</p>
+
+<p>
+  If you want both schemas and source schemas, you can query the "xtk:entity" schema instead. But this requires an
+  additional condition en the "@entitySchema" attribute. If not, you will also get custom forms, javascript, etc.
+</p>
+
+<pre class="code">
+
+  const queryDef = {
+    schema: "xtk:entity",
+    operation: "select",
+    lineCount: 10,
+    select: {
+        node: [
+            { expr: "@name" },
+            { expr: "@namespace" },
+            { expr: "@label" },
+            { expr: "@entitySchema" },
+        ]
+    },
+    where: {
+      condition: [
+        { expr:`@namespace = 'cus'` },
+        { expr:`@entitySchema IN ('xtk:schema', 'xtk:srcSchema')` }
+        ]
+    }
+  };
+  const query = client.NLWS.xtkQueryDef.create(queryDef);
+  const entities = await query.executeQuery();
+  </pre>
+  
+
+  <h2>Use a query to get schema details</h2>
+
+  <p>
+    Schemas are stored into the xtk:entity table. The main fields (@name, @label, @namespace) are stored directly
+    as SQL columns, but the schema definition is actually stored as XML. 
+    Getting the XML requires to query at least one of attibutes which is stored in XML, for example
+    the @library attribute.
+  </p>
+
+  <pre class="code">
+
+    const queryDef = {
+      schema: "xtk:schema",
+      operation: "get",
+      select: {
+          node: [
+              { expr: "@name" },
+              { expr: "@namespace" },
+              { expr: "@label" },
+              { expr: "@library" },
+          ]
+      },
+      where: {
+        condition: [
+          { expr:`@namespace = 'nms' and @name='recipient'` },
+        ]
+      }
+    };
+    const query = client.NLWS.xtkQueryDef.create(queryDef);
+    const schema = await query.executeQuery();
+  </pre>
+
+
+<p>
+  Note that querying for schemas (as opposed to srcSchemas) the id is the id of the top most src schema (i.e. "nms:recipient" and not "cus:recipient").
+  The reason is that all source schemas (nms:recipient, cus:recipient, etc.) are merged into a single schema (nms:recipient) when compiled.
+  You can, however, query individual source schemas even if they are extension schemas
+</p>
+
+<pre class="code">
+  const queryDef = {
+    schema: "xtk:srcSchema",
+    operation: "get",
+    select: {
+        node: [
+            { expr: "@name" },
+            { expr: "@namespace" },
+            { expr: "@label" },
+            { expr: "@library" },
+        ]
+    },
+    where: {
+      condition: [
+        { expr:`@namespace = 'gov' and @name='recipient'` },
+      ]
+    }
+  };
+  const query = client.NLWS.xtkQueryDef.create(queryDef);
+  const srcSchema = await query.executeQuery();
+</pre>
+
+<h2>Use GetEntityIfMoreRecent</h2>
+<p>
+  Last, but not least, you can use the <b>xtk:persist#GetEntityIfMoreRecent</b> method to return a (compiled) schema. This is the method internally
+  used by the SDK. This method is useful if you already have the schema but you are not sure it's up to date. Calling this method is usefull to
+  save network bandwidth as it will only return the schema if it has changed.
+</p>
+<p> 
+  For this, you need to keep both the schema and its md5 hash (@md5 attribute). Then you can call the method as follows:
+  <ul>
+    <li>Pass an identifier to the schema. As GetEntityIfMoreRecent works with any type of entities, the id is formatted as "xtk:srcSchema:{schemaId}" or "xtk:schema:{schemaId}" </li>
+    <li>Pass the MD5 of the schema if you have it. If you pass undefined, the API call will return the full schema. If you pass a md5, the API will only return a schema if it has changed</li>
+    <li>Pass a boolean indicating if you expect the requested entity to exist. If false, then the API will return null for non existent entities</li>
+  </ul>
+</p>
+
+<pre class="code">
+const schema = await client.NLWS.xtkSession.getEntityIfMoreRecent("xtk:srcSchema|nms:notFound", md5, mustExist);
+</pre>
+
+
+
+<h1>Creating and updating schemas</h1>
+
+<p>
+  The following API calls can be used to either create or update schemas. Note the builtin schemas cannot be updated. 
+  The operation is always a two-step process:
+  <ui>
+    <li>Create or modify a source schema</li>
+    <li>Call one of the <b>BuildSchema</b> methods</li>
+  </ui>
+</p>
+
+<p class="warning">Always work with source schemas for creation and update. Tampering with (compiled) schemas can lead to inconsistencies and unpredictable results.</p>
+
+<h2>Create (or modify) a custom schema</h2>
+
+<p>
+  In this example we'll create or update a simple custom schema. This is the simplest scenario, there's no schema extension, etc.
+</p>
+
+<pre class="code">
+await client.NLWS.xtkSession.write({ 
+  xtkschema: "xtk:srcSchema", 
+  namespace: "cus",
+  name: "foo",
+  label: "Foos",
+  labelSingular: "Foo",
+  desc: "This is a fooooo", 
+  mappingType: "sql",
+  element: [
+    {
+      name: "foo",
+      key: [
+        {
+          name: "id",
+          keyfield: [
+            {
+              xpath: "@id"
+            }
+          ]
+        }
+      ],
+      attribute: [
+        {
+          name: "id", 
+          label: "Id",
+          type: "string",
+          length: 100
+        }
+      ]
+    }
+  ]
+});
+</pre>
+
+<p>
+  <ul>
+    <li>Make sure to pass the attribute xtkschema: "xtk:srcSchema". This means that we are creating or updating a source schema</li>
+    <li>Do not modify (compiled) schemas directly</li>
+    <li>The function does not return anything. You can a queryDef to verify that the source schema was properly created</li>
+    <li>By convention, the schema name is <i>singular</i>, in camel case, starting with a lower case character</li>
+    <li>The label is the human friendly name and is plural, whereas labelSingular is for ... singular</li>
+    <li>It's important to set the mapping type to SQL, indicating that we want a SQL table created</li>
+    <li>Create a root element with the <i>same name</i> as the schema</li>
+    <li>Although it's not mandatory to have a primary key, it's a best practice. Create a <i>key</i> element</li>
+  </ul>
+</p>
+
+<p>
+  Now, build the schema. This operation may take a few seconds, adjust the timeout accordingly.
+</p>
+
+<pre class="code">
+await client.NLWS.pushDown({ timeout: 60000 }).xtkBuilder.BuildSchemaFromId("cus:foo");
+</pre>
+<p class="warning">
+  Do not forget to call one of the <b>xtk:builder#BuildSchema</b>
+</p>
+
+
+
+<h1>Deleting a schema</h1>
+
+<p>
+  Before you can delete a source schema you need to get it's <b>@extendedSchema</b> attribute. The following will
+  return the id of the parent schema if cus:foo is an extension schema, or undefined if cus:foo is not an extension schema.
+</p>
+
+<pre class="code">
+const queryDef = {
+  schema: "xtk:srcSchema",
+  operation: "get",
+  select: {
+      node: [
+          { expr: "@extendedSchema" },
+      ]
+  },
+  where: {
+    condition: [
+      { expr:`@namespace = 'cus' and @name='foo'` },
+    ]
+  }
+};
+const query = client.NLWS.xtkQueryDef.create(queryDef);
+const srcSchema = await query.executeQuery();
+const extendedSchema = srcSchema.extendedSchema;
+</pre>  
+
+<p>
+  To remove a schema, a writer to delete the source schema entities you want to delete. Make sure to pass the extendedSchema if there is one.
+</p>
+
+<pre class="code">
+await client.NLWS.xtkSession.writeCollection({ 
+  xtkschema: "xtk:srcSchema", 
+  srcSchema: [
+    {
+      _operation: "delete",
+      extendedSchema: extendedSchema,
+      namespace: "cus",
+      name: "foo"
+    }
+  ]
+});
+</pre>
+
+<p>
+  Now, call the <b>xtk:builder#RemoveSchemaLinkRef</b> method to remove the schema and reverse links. Make sure to pass the extendedSchema if there is one.
+</p>
+<pre class="code">
+await client.NLWS.xtkBuilder.RemoveSchemaLinkRef("cus:foo", extendedSchema);
+</pre>
+
+<p>
+  If the schema you want to delete has extension schema 
+</p>

package/docs/_posts/2023-12-09-createFDASchema.html

@@ -0,0 +1,429 @@
+---
+layout: post
+title:  "Discover and create a FDA schema"
+author: Alexandre Morin
+tags: fda schemas soap
+excerpt: Sequence of APIs to discover and create a FDA schema
+---
+
+
+<p>
+  This article will illustrate the following flow and show the corresponding SOAP calls.
+  <ul>
+    <li>Create an external account corresponding to a FDA PostgreSQL database</li>
+    <li>Discover all the tables available in the FDA database</li>
+    <li>Choose a table and discover the schema</li>
+    <li>Annotate and save the schema</li>
+  </ul>
+</p>
+
+<h1>Create FDA external account</h1>
+
+<p>
+  We'll create (or update) an external acount for a FDA database. You need the server, port, database and schema name, user and password. 
+</p>
+
+<h2>Encrypt the password</h2>
+
+<p>
+  The first step is to encrypt the password. 
+  The <b>xtk:persist#EncryptPassword</b> API will by used to encrypt the password.
+</p>
+
+<p></p>
+
+<pre class="code">
+&lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+&lt;SOAP-ENV:Body&gt;
+
+&lt;EncryptPassword xmlns='urn:xtk:persist' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+&lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+      
+	      &lt;strDecrypted xsi:type='xsd:string'&gt;admin&lt;/strDecrypted&gt;
+
+&lt;/EncryptPassword&gt;
+&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+
+</pre>
+
+<p>
+  The API will return the encrypted password as follows.
+</p>
+
+<pre class="code">
+&lt;?xml version='1.0'?&gt;
+&lt;SOAP-ENV:Envelope
+	xmlns:xsd='http://www.w3.org/2001/XMLSchema'
+	xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+	xmlns:ns='urn:xtk:session'
+	xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+	&lt;SOAP-ENV:Body&gt;
+		&lt;EncryptPasswordResponse
+			xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+			&lt;pstrEncrypted xsi:type='xsd:string'&gt;@S/U/D7xOdZfRAwf3+WRM3w==&lt;/pstrEncrypted&gt;
+		&lt;/EncryptPasswordResponse&gt;
+	&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+</pre>
+
+
+<h2>Create the external account</h2>
+
+<p>
+  Now the external account can be created using the <b>xtk:persist#Write</b> API. Give it a name, make sure it's active and set all connection parameters as follows. Make sure you provide the encrypted password
+</p>
+
+<pre class="code">
+  &lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+    &lt;SOAP-ENV:Body&gt;
+    
+    &lt;Write xmlns='urn:xtk:persist' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+    &lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+          &lt;domDoc xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+    
+            &lt;extAccount xtkschema="nms:extAccount" 
+                name="pg2" label="Postgres (2)" provider="PostgreSQL" type="7" active="1"
+                server="localhost" port="" dbName="fda" dbSchema="public" 
+                account="postgres" password="@S/U/D7xOdZfRAwf3+WRM3w=="
+                timezone="_server_" unicodeData="1"&gt;
+            &lt;/extAccount&gt;
+    
+          &lt;/domDoc&gt;
+    &lt;/Write&gt;
+    &lt;/SOAP-ENV:Body&gt;
+    &lt;/SOAP-ENV:Envelope&gt;
+</pre>
+
+<p>
+  The API does not return anything. Note the the <b>name</b> attribute is a unique key in the nms:account schema. So the same API call can be used to update the account.
+</p>
+
+<h2>Test the connection</h2>
+
+<p>
+  Campaign provides the <b>nms:extAccount#TestAccount</b> API to test the connection. Unfortunately, this API cannot take an extAccount id, but it needs to be passed all the credentials settings again.
+  Note that the password is still encrypted.
+</p>
+
+<pre class="code">
+
+  &lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+    &lt;SOAP-ENV:Body&gt;
+    
+    &lt;TestAccount xmlns='urn:xtk:persist' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+    &lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+    
+          &lt;param xsi:type='xsd:byte'&gt;7&lt;/param&gt;
+          &lt;param xsi:type='xsd:boolean'&gt;1&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;PostgreSQL:localhost&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;postgres&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;@S/U/D7xOdZfRAwf3+WRM3w==&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;fda&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;NChar=0;unicodeData=1;timezone=_server_;dbSchema=public;fileMethod=uploadFile;filePath=;&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;pg2&lt;/param&gt;
+          &lt;param xsi:type='xsd:boolean'&gt;0&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;&lt;/param&gt;
+          &lt;param xsi:type='xsd:string'&gt;&lt;/param&gt;
+      
+      &lt;/TestAccount&gt;
+    &lt;/SOAP-ENV:Body&gt;
+    &lt;/SOAP-ENV:Envelope&gt;
+        
+</pre>
+
+<p>
+  This should return a string with version information.
+</p>
+
+<pre class="code">
+&lt;?xml version='1.0'?&gt;
+&lt;SOAP-ENV:Envelope
+	xmlns:xsd='http://www.w3.org/2001/XMLSchema'
+	xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+	xmlns:ns='urn:nms:extAccount'
+	xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+	&lt;SOAP-ENV:Body&gt;
+		&lt;TestAccountResponse
+			xmlns='urn:nms:extAccount' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+			&lt;pstrServer xsi:type='xsd:string'&gt;localhost&lt;/pstrServer&gt;
+			&lt;pstrDbmsVer xsi:type='xsd:string'&gt;Database server version &#39;PostgreSQL 12.2, compiled by Visual C++ build 1914, 64-bit&#39;.&lt;/pstrDbmsVer&gt;
+			&lt;pstrWarehouse xsi:type='xsd:string'&gt;&lt;/pstrWarehouse&gt;
+			&lt;pstrTestDuration xsi:type='xsd:string'&gt;Test connection took: 0 ms&lt;/pstrTestDuration&gt;
+		&lt;/TestAccountResponse&gt;
+	&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+</pre>
+
+
+<h2>Query the external account</h2>
+
+<p>
+  You can also use a query to get information about the external account.
+</p>
+
+<pre class="code">
+&lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+&lt;SOAP-ENV:Body&gt;
+
+&lt;ExecuteQuery xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+&lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+
+      &lt;entity xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+        &lt;queryDef fullLoad="true" operation="get" schema="nms:extAccount" startPath="/" xtkschema="xtk:queryDef"&gt;
+          &lt;select&gt;
+            &lt;node expr="@id"/&gt;
+            &lt;node expr="@name"/&gt;
+            &lt;node expr="@label"/&gt;
+            &lt;node expr="@provider"/&gt;
+            &lt;node expr="@active"/&gt;
+            &lt;node expr="@server"/&gt;
+            &lt;node expr="@port"/&gt;
+            &lt;node expr="@dbName"/&gt;
+            &lt;node expr="@dbSchema"/&gt;
+            &lt;node expr="@account"/&gt;
+            &lt;node expr="@password"/&gt;
+            &lt;node expr="@timezone"/&gt;
+            &lt;node expr="@unicodeData"/&gt;
+          &lt;/select&gt;
+          &lt;where&gt;
+            &lt;condition expr="@name='pg2'"/&gt;
+          &lt;/where&gt;
+        &lt;/queryDef&gt;
+      &lt;/entity&gt;
+
+&lt;/ExecuteQuery&gt;
+
+
+&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+
+</pre>
+
+<p>
+  It will return something like this
+</p>
+
+<pre class="code">
+&lt;?xml version='1.0'?&gt;
+&lt;SOAP-ENV:Envelope
+	xmlns:xsd='http://www.w3.org/2001/XMLSchema'
+	xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+	xmlns:ns='urn:xtk:queryDef'
+	xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+	&lt;SOAP-ENV:Body&gt;
+		&lt;ExecuteQueryResponse
+			xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+			&lt;pdomOutput xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+				&lt;extAccount account="postgres" active="1" dbName="fda" dbSchema="public" id="4510" label="Postgres (2)" name="pg2" password="@S/U/D7xOdZfRAwf3+WRM3w==" port="" provider="PostgreSQL" server="localhost" timezone="_server_" unicodeData="1"&gt;&lt;/extAccount&gt;
+			&lt;/pdomOutput&gt;
+		&lt;/ExecuteQueryResponse&gt;
+	&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+
+</pre>
+
+
+<h1>Discover the tables</h1>
+
+<p>
+  Now you can discover the tables available in the FDA database. The <b>xtk:sqlSchema#BuildTableList</b> API will return a list of tables.
+</p>
+
+<pre class="code">
+&lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+&lt;SOAP-ENV:Body&gt;
+
+&lt;BuildTableList xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+&lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+
+			&lt;param xsi:type='xsd:string'&gt;nms:extAccount:pg2&lt;/param&gt;
+			&lt;param xsi:type='xsd:string'&gt;%%&lt;/param&gt;
+
+&lt;/BuildTableList&gt;
+
+&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+</pre>
+
+<p>
+  Which returns the following. In this example, I only have one table named <b>x</b>.
+</p>
+
+<pre class="code">
+  &lt;?xml version='1.0'?&gt;
+  &lt;SOAP-ENV:Envelope
+    xmlns:xsd='http://www.w3.org/2001/XMLSchema'
+    xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+    xmlns:ns='urn:xtk:sqlSchema'
+    xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+    &lt;SOAP-ENV:Body&gt;
+      &lt;BuildTableListResponse
+        xmlns='urn:xtk:sqlSchema' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+        &lt;pdomTableList xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+          &lt;sqlSchema&gt;
+            &lt;table name="public.x"/&gt;
+          &lt;/sqlSchema&gt;
+        &lt;/pdomTableList&gt;
+      &lt;/BuildTableListResponse&gt;
+    &lt;/SOAP-ENV:Body&gt;
+  &lt;/SOAP-ENV:Envelope&gt;
+</pre>  
+
+
+<h1>Create the schema</h1>
+
+<p>
+  Schema creation is a 3-step process
+  <ul>
+    <li>First, create a sql schema by discovering the table structure in the FDA database</li>
+    <li>Second, modify the schema if necessary and save it as a source schema</li>
+    <li>Finally, build the final schema</li>
+  </ul>
+</p>
+
+<h2>Discover the table structure</h2>
+
+<p>
+  We'll call the <b>xtk:builder#GenerateSchema</b> API. It's the API behind the schema creation wizard.
+  This API takes high level parameters and return an XML document which is the future schema. Note that
+  everything happens in memory. At this point, nothing is created in the database.
+</p>
+<p>
+  The rationale is that the discovery may not discover anything, so we return a source schema, give you
+  a chance to modify it before it is persisted.
+</p>
+
+<pre class="code">
+&lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+&lt;SOAP-ENV:Body&gt;
+
+&lt;GenerateSchema xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+&lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+
+      &lt;param xsi:type='xsi:element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+        &lt;tmp type="extView" sqltable="public.x" removePrefix="0" advanced="0"&gt;
+        &lt;/tmp&gt;
+      &lt;/param&gt;
+
+	    &lt;param xsi:type='xsi:element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+        &lt;srcSchema dataSource="nms:extAccount:pg2" img="xtk:schema.png" label="NewAPI" mappingType="sql" name="new2" namespace="cus" xtkschema="xtk:srcSchema"&gt;
+        &lt;/srcSchema&gt;
+      &lt;/param&gt;
+
+&lt;/GenerateSchema&gt;
+
+&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+</pre>
+
+<p>
+  Which returns
+</p>
+
+<pre class="code">
+&lt;?xml version='1.0'?&gt;
+&lt;SOAP-ENV:Envelope
+	xmlns:xsd='http://www.w3.org/2001/XMLSchema'
+	xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+	xmlns:ns='urn:xtk:builder'
+	xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+	&lt;SOAP-ENV:Body&gt;
+		&lt;GenerateSchemaResponse
+			xmlns='urn:xtk:builder' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+			&lt;pdomSchema xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+
+      &lt;srcSchema img="xtk:schema.png" label="NewAPI" mappingType="sql" name="new2" namespace="cus" view="true" xtkschema="xtk:srcSchema"&gt;
+					&lt;element dataSource="nms:extAccount:pg2" label="NewAPI" name="new2" sqltable="public.x"&gt;
+						&lt;attribute advanced="false" label="i" name="i" sqlname="i" type="long"/&gt;
+					&lt;/element&gt;
+				&lt;/srcSchema&gt;
+
+        &lt;/pdomSchema&gt;
+		&lt;/GenerateSchemaResponse&gt;
+	&lt;/SOAP-ENV:Body&gt;
+&lt;/SOAP-ENV:Envelope&gt;
+</pre>
+
+<p>
+  As you can see a src schema is returned. In this case, my table only had one column named "i" which is a long.
+</p>
+
+<h2>Create the schema</h2>
+
+<p>
+  Let's extract the srcSchema object from the result of the previous API call. We can modify this XML document 
+  and, for example, define links, labels, keys, etc.
+
+  Typically, we'll create at least a key as follows
+</p>
+<pre class="code">
+  &lt;srcSchema img="xtk:schema.png" label="NewAPI" mappingType="sql" name="new2" namespace="cus" view="true" xtkschema="xtk:srcSchema"&gt;
+  &lt;element dataSource="nms:extAccount:pg2" label="NewAPI" name="new2" sqltable="public.x"&gt;
+    &lt;key name="pk"&gt;
+      &lt;keyfield xpath="@i"/&gt;
+    &lt;/key&gt;
+    &lt;attribute advanced="false" label="i" name="i" sqlname="i" type="long"/&gt;
+  &lt;/element&gt;
+&lt;/srcSchema&gt;
+</pre>
+<p>
+  When happy with the document, it's time to save it and persist the src schema in the database. This
+  can be done with a simple <b>xtk:persist#Write</b> API call.
+</p>
+
+<pre class="code">
+  &lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+    &lt;SOAP-ENV:Body&gt;
+    
+    &lt;Write xmlns='urn:xtk:persist' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+    &lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+    
+          &lt;domDoc xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'&gt;
+    
+            &lt;srcSchema img="xtk:schema.png" label="NewAPI" mappingType="sql" name="new2" namespace="cus" view="true" xtkschema="xtk:srcSchema"&gt;
+              &lt;element dataSource="nms:extAccount:pg2" label="NewAPI" name="new2" sqltable="public.x"&gt;
+                &lt;key name="pk"&gt;
+                  &lt;keyfield xpath="@i"/&gt;
+                &lt;/key&gt;
+                &lt;attribute advanced="false" label="i" name="i" sqlname="i" type="long"/&gt;
+              &lt;/element&gt;
+            &lt;/srcSchema&gt;
+    
+          &lt;/domDoc&gt;
+    
+    &lt;/Write&gt;
+    
+    
+    &lt;/SOAP-ENV:Body&gt;
+    &lt;/SOAP-ENV:Envelope&gt;
+</pre>    
+
+<p>
+  This API call does not return anything. But you can check in the database, the schema is there.
+</p>
+
+<h2>Build the schema</h2>
+
+<p>
+  The last step is very important and consists of building a xtk:schema from the xtk:srcSchema which has
+  just been created. We can use the <b>xtk:builder#BuildSchemaFromId</b> API call.
+</p>
+
+<pre class="code">
+  &lt;SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:persist' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'&gt;
+    &lt;SOAP-ENV:Body&gt;
+    
+    &lt;BuildSchemaFromId xmlns='urn:xtk:builder' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'&gt;
+    &lt;__sessiontoken xsi:type='xsd:string'&gt;{{SESSION_TOKEN}}&lt;/__sessiontoken&gt;
+    
+      &lt;schemaId&gt;cus:new2&lt;/schemaId&gt;
+    
+    &lt;/BuildSchemaFromId&gt;
+    
+    
+    &lt;/SOAP-ENV:Body&gt;
+    &lt;/SOAP-ENV:Envelope&gt;
+</pre>      

package/docs/blog.html

@@ -8,7 +8,7 @@ title: Blog (latest posts)
     {% for post in site.posts %}
       <li>
         <div class="blog-expert">
-          <h2><a href="{{ post.url }}">{{ post.title }}</a></h2>
+          <h2><a href="{{ site.baseurl }}/{{ post.url }}">{{ post.title }}</a></h2>
           <div class="blog-header">{{ post.author }} - {{ post.date | date_to_string }}</div>
           {{ post.excerpt }}
         </div>

package/docs/changeLog.html

@@ -2,6 +2,30 @@
 layout: page
 title: Change Log
 ---
+<section class="changelog"><h1>Version 1.1.43</h1>
+  <h2>2023/12/21</h2>
+  <li>
+    Do not throw an error in case of duplicate enumeration value. Use the last one instead. This introduces a small behavior change
+    because this was causing an exception before.
+  </li>
+</section>
+
+
+<section class="changelog"><h1>Version 1.1.42</h1>
+  <h2>2023/12/20</h2>
+  <li>
+    Fixed a typo in documentation
+  </li>
+  <li>
+    Added 2 blog articles about schema creation (SOAP calls)
+  </li>
+  <li>
+    Fixed the documentation: blog articles links were broken
+  </li>
+  <li>
+    Upgraded Axios to fix a vulnerability
+  </li>
+</section>
 
 <section class="changelog"><h1>Version 1.1.41</h1>
   <h2>2023/11/01</h2>

package/docs/connecting.html

@@ -105,7 +105,7 @@ await client.logoff();
 </p>
 
 <h2>Login with user and password</h2>
-<p>This is the most common method to log in to Campaign. User the <b>ofUserAndPassword</b> function and pass it the user name and password</p>
+<p>This is the most common method to log in to Campaign. Use the <b>ofUserAndPassword</b> function and pass it the user name and password</p>
 <pre class="code">
 const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword(
     "https://myInstance.campaign.adobe.com", 

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.41",
+  "version": "1.1.43",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@adobe/acc-js-sdk",
-      "version": "1.1.41",
+      "version": "1.1.43",
       "license": "ISC",
       "dependencies": {
         "axios": "^1.2.1",
@@ -1322,8 +1322,9 @@
       "license": "MIT"
     },
     "node_modules/axios": {
-      "version": "1.2.1",
-      "license": "MIT",
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.6.2.tgz",
+      "integrity": "sha512-7i24Ri4pmDRfJTR7LDBhsOTtcm+9kjX5WiY1X3wIisx6G9So3pfMkEiU7emUBe46oceVImccTEM3k6C5dbVW8A==",
       "dependencies": {
         "follow-redirects": "^1.15.0",
         "form-data": "^4.0.0",
@@ -5599,7 +5600,9 @@
       "version": "0.4.0"
     },
     "axios": {
-      "version": "1.2.1",
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.6.2.tgz",
+      "integrity": "sha512-7i24Ri4pmDRfJTR7LDBhsOTtcm+9kjX5WiY1X3wIisx6G9So3pfMkEiU7emUBe46oceVImccTEM3k6C5dbVW8A==",
       "requires": {
         "follow-redirects": "^1.15.0",
         "form-data": "^4.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.41",
+  "version": "1.1.43",
   "description": "ACC Javascript SDK",
   "main": "src/index.js",
   "homepage": "https://github.com/adobe/acc-js-sdk#readme",

package/src/util.js

@@ -196,13 +196,17 @@ class ArrayMap {
 
   _push(key, value, withoutIndexing) {
       let isNumKey = false;
+      let updateIndex = -1;
+
       if (key) {
         // reserved keyworkds
         const isReserved = key === "_items" || key === "length" || key === "_push" || key === "forEach" || key === "map" || key === "_map" || key === "get" || key === "find" || key === "flatMap" || key === "filter";
 
         // already a child with the name => there's a problem with the schema
-        if (!isReserved && this[key]) 
-          throw new Error(`Failed to add element '${key}' to ArrayMap. There's already an item with the same name`);
+        // it seems the current behavior is to replace the existing item with the new one
+        if (!isReserved && this[key]) {
+          updateIndex = this._items.indexOf(this[key]);
+        }
 
         // Set key as a enumerable property, so that elements can be accessed by key, 
         // but also iterated on with a for ... in loop
@@ -222,14 +226,19 @@ class ArrayMap {
       if (!withoutIndexing && !isNumKey) {
         // Set the index property so that items can be accessed by array index.
         // However, make it non-enumerable to make sure indexes do not show up in a for .. in loop
-        Object.defineProperty(this, this._items.length, {
+        const numKey = updateIndex == -1 ? this._items.length : updateIndex;
+        Object.defineProperty(this, numKey, {
           value: value,
           writable: false,
           enumerable: false,
+          configurable: true, // Allow to redefine the property later in case there's a duplicate key
         });
       }
       // Add to array and set length
-      this._items.push(value);
+      if (updateIndex == -1)
+        this._items.push(value);
+      else
+        this._items[updateIndex] = value;
       this.length = this._items.length;
   }
 

package/test/application.test.js

@@ -45,13 +45,37 @@ describe('Application', () => {
             });
 
             it("Duplicate root nodes", () => {
-                expect(() => {
-                    var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
-                                                <element name='recipient' label='Recipients'/>
-                                                <element name='recipient' label='Recipients2'/>
-                                            </schema>`);
-                    newSchema(xml);    
-                }).toThrow("Failed to add element 'recipient' to ArrayMap. There's already an item with the same name");
+                var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
+                                            <element name='recipient' label='Recipients'/>
+                                            <element name='recipient' label='Recipients2'/>
+                                        </schema>`);
+                var schema = newSchema(xml);
+                var root = schema.root;
+                expect(root).toBeTruthy();
+                expect(root.name).toBe("recipient");
+                expect(root.label).toBe("Recipients2");
+            });
+
+            it("Duplicate enumeration value", () => {
+                const xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
+                                            <enumeration basetype="string" name="AKA">
+                                                <value name="PC" value="1"/>
+                                                <value name="CL2" value="2"/>
+                                                <value name="CL3" value="3"/>
+                                                <value name="Null" value="4"/>
+                                                <value name="Null" value="NULL"/>
+                                            </enumeration>
+                                            <element name='recipient' label='Recipients'/>
+                                        </schema>`);
+                const schema = newSchema(xml);
+                const enumerations = schema.enumerations;
+                const enumeration = enumerations.AKA.values;
+                expect(enumeration.length).toBe(4);
+                expect(enumeration[0].name).toBe("PC");
+                expect(enumeration[1].name).toBe("CL2");
+                expect(enumeration[2].name).toBe("CL3");
+                expect(enumeration[3].name).toBe("Null");
+                expect(enumeration[3].value).toBe("NULL");
             });
 
             it("Should find root node", () => {

package/test/util.test.js

@@ -371,10 +371,26 @@ describe('Util', function() {
             expect(cat).toBe("012");
         });
 
-        it("Should not support adding the same key twice", () => {
+        it("Should support adding the same key twice. The last value overwrites", () => {
             const am = new ArrayMap();
             am._push("hello", "Hello");
-            expect(() => { am._push("hello", "World"); }).toThrow("Failed to add element 'hello' to ArrayMap. There's already an item with the same name");
+            expect(am.length).toBe(1);
+            am._push("hello", "World");
+            expect(am.length).toBe(1);
+            expect(am.get(0)).toBe("World");
+        });
+
+        it("Should support adding the same key twice. The last value overwrites in the middle of the array", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("cruel", "Cruel");
+            am._push("world", "World");
+            expect(am.length).toBe(3);
+            am._push("cruel", "*cruel*");
+            expect(am.length).toBe(3);
+            expect(am.get(0)).toBe("Hello");
+            expect(am.get(1)).toBe("*cruel*");
+            expect(am.get(2)).toBe("World");
         });
 
         it("Should support missing names", () => {