@mcpher/gas-fakes 1.0.8 → 1.0.9

package/README.md

@@ -28,7 +28,7 @@ You don't have access to the GAS maintained cloud project, so you'll need to cre
 
 ### Testing
 
-I recommend you use the test project included in the repo to make sure all is set up correctly. It uses a Fake DriveApp service to excercise Auth etc. Just change the fixtures in .env_template in your own environments, then `npm i && npm test`. 
+I recommend you use the test project included in the repo to make sure all is set up correctly. It uses a Fake DriveApp service to excercise Auth etc. Just change the fixtures in your own environments by following the instructions in [setup-env.md](https://github.com/brucemcpherson/gas-fakes/blob/main/setup-env.MD), then `npm i && npm test`.
 
 Note that I use a [unit tester](https://ramblings.mcpher.com/apps-script-test-runner-library-ported-to-node/) that runs in both GAS and Node, so the exact same tests will run in both environments. There are some example tests in the repo. Each test has been proved on both Node and GAS. There's also a shell (togas.sh) which will use clasp to push the test code to Apps Script.
 
@@ -92,28 +92,7 @@ Although Apps Script supports async/await/promise syntax, it operates in blockin
 
 Since asynchonicity is fundamental to Node, there's no real simple way to convert async to sync. However, there is such a thing as a [child-process](https://nodejs.org/api/child_process.html#child-process) which you can start up to run things, and it features an [execSync](https://nodejs.org/api/child_process.html#child_processexecsynccommand-options) method which delays the return from the child process until the promise queue is all settled. So the simplest solution is to run an async method in a child process, wait till it's done, and return the results synchronously. I found that [Sindre Sorhus](https://github.com/sindresorhus) uses this approach with [make-synchronous](https://github.com/sindresorhus/make-synchronous), so I'm using that.
 
-Here's a simple example of how to get info on an access token made synchronous
-
-```js
-/**
- * a sync version of token checking
- * @param {string} token the token to check
- * @returns {object} access token info
- */
-const fxCheckToken = (accessToken) => {
-  // now turn all that into a synchronous function - it runs as a subprocess, so we need to start from scratch
-  const fx = makeSynchronous(async (accessToken) => {
-    const { default: got } = await import("got");
-    const tokenInfo = await got(
-      `https://www.googleapis.com/oauth2/v3/tokeninfo?access_token=${accessToken}`
-    ).json();
-    return tokenInfo;
-  });
-
-  const result = fx(accessToken);
-  return result;
-};
-```
+Runnng up a child process in Node is pretty expensive and slow (especially of you're running in debug mode in vscode), so I'll be looking for ways to speed that up when I get to it.
 
 ### OAuth
 
@@ -172,14 +151,14 @@ This was a little problematic to sequence, but I wanted to make sure that any GA
 
 Only a subset of methods are currently available for some of them - the rest are work in progress. My approach is to start with a little bit of each service to prove feasibility and provide a base to build on.
 
-v1.0.7
+v1.0.8
 
 - `DriveApp` - 50%
 - `ScriptApp` - almost all
 - `UrlFetchApp` - 80%
 - `Utilities` - almost all
 - `Sheets` - 25%
-- `SpreadsheetApp` - 25%
+- `SpreadsheetApp` - 60%
 - `CacheService` - 80%
 - `PropertiesService` - 80%
 - `Session` - almost all
@@ -195,184 +174,193 @@ Tests for all methods are added as we go to the cumulative unit tests and run on
 
 Each service has a FakeClass but I needed the Auth cycle to be initiated and done before making them public. Using a proxy was the simplest approach.
 
-Here's the code for `Utilities`
+In short, the service is registered as an empty object, but when any attempt is made to access it actually returns a different object which handles the request. In the `ScriptApp` example, `ScriptApp` is an empty object, but accessing `ScriptApp.getOAuthToken()` returns an Fake `ScriptApp` object which gets initialized if you try to access it.
 
-```js
-/**
- * adds to global space to mimic Apps Script behavior
- */
-import { Proxies } from "../../support/proxies.js";
-import { newFakeUtilities } from "./fakeutilities.js";
-
-// This will eventually hold a proxy for Utilties
-let _app = null;
-
-/**
- * adds to global space to mimic Apps Script behavior
- */
-const name = "Utilities";
-if (typeof globalThis[name] === typeof undefined) {
-  const getApp = () => {
-    // if it hasnt been intialized yet then do that
-    if (!_app) {
-      console.log(`setting ${name} to global`);
-      _app = newFakeUtilities();
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app;
-  };
-  Proxies.registerProxy(name, getApp);
-}
+There's also a test available to see if you are running in GAS or on Node - `ScriptApp.isFake`. In fact this method 'isFake' is available on any of the implemented services, eg `DriveApp.isFake`.
+
+### Iterators
+
+An iterator created by a generator does not have a `hasNext()` function, whereas GAS iterators do. To get round this, I use a regular Node iterator, but with a wrapper so the constructor actually gets the first one, and `next()` uses the value we've already peeked at.
+
+### Cache and Property services
+
+These are currently implemented using [keyv](https://github.com/jaredwray/keyv) with storage adaptor [keyv-file](https://github.com/zaaack/keyv-file).The `gasfakes.json` file is used to commiicate where these files should be. I've gone for local file storage rather than something like redis to avoid adding local service requirements, but keyv takes a wide range of storage adaptors if you want to do something fancier. A small modificaion to kv.js is all you need.
+
+#### Script, user and document store varieties
+
+All 3 are supported for both properties and cache.
+
+##### scriptId
+
+The local version may have no knowledge of the Apps ScriptId. If you are using clasp, it's picked up from the .clasp.json file. However if you are not using clasp, or want to use something else, you can set the scriptId in `gasfakes.json`, otherwise it'll create a fake id use that. All property and cache stores use the scriptId to partition data.
+
+##### userId
+
+The userId is extracted from an accessToken and will match the id derived from Application Default Credentials. This means that you can logon as a different user to test user data isolation. All user level property and cache stores use the scriptId and userId to partition data.
+
+##### documentId
+
+The documentId is only meaningful if you are working on a container bound scrip. We use the the documentId property of gasfakes.json to identify a container file. All document level property and cache stores use the scriptId and documentId to partition data.
+
+### Settings and temporary files
+
+As you will have noticed, there are various local support files for props/caching etc. Be careful that these do not get committed to a public repo if you are adding sensitive values to your stores. Note that the real user Id is not used when creating files, but rather an encrypted version of it. This avoids real user ids being revealed in your file system.
+
+## Noticed differences
+
+I'll make a note in thre repos issues on implementation differences. In the main will be slight differences in error message text, which I'll normalize over time, or where Apps Script has a fundamental obstacle. Please report any differences in behavior you find in the repo issues.
+
+### Tradeoffs
+
+I've come across various Apps Script bugs/issues as I work through this which I've reported to the GAS team, and added workarounds in the gas fakes code - not sure at this point whether to duplicate the buggy behavior or simulate what would seem to be the correct one. Again - any things you come across please use the issues in the repo to report.
+
+## Oddities
+
+Just a few things I've come across when digging into the differences between what the sheets API and Apps Script do. Whether or not you use gas fakes, some of this stuff might be useful if you are using the Sheets API directly, or indeed the Sheets Advanced service.
+
+### Formats and styles
+
+When getting formats with the sheets API, there are 2 types
+
+- userEnteredFormat - any formats a user (or an apps script function) has explicitly set
+- effectiveFormat - what rendered format actually looks like
+
+This means that sometimes, for example, a font might be red in the UI, but Apps Script reports it as black. This is because Apps Script uses the userEnteredFormat exclusively (I think). I've implemented the same in Gas Fakes. To get the effectiveFormat, you'll need to use the Fake Advanced Sheets service, just as you would in Apps Script.
+
+### Values
+
+Just as with Formats, the actual value rendered might be different than the value stored. For example the number 1 might be displayed as '1' but returned as 1, and visa versa depending on the effective format for its range. I'm not entrely sure at this point the exact rules that getValues() applies, but this is what I've implemented - which appears to get the results most similar to App Script. I haven't figured out how to handles dates yet.
+
+Here is how I've implemented getting and setting values.
+
+- getValues() uses { valueRenderOption: 'UNFORMATTED_VALUE' }
+- setValues() uses { valueInputOption: "RAW" } (as opposed to 'USER_ENTERED')
+- getDisplayValues() { valueRenderOption: 'FORMATTED_VALUE' }
+
+### Data Validation
+
+There's quite a few oddities in Data Validation, which turned out to be the most complicated topic I've tackled at the time of writing.
+
+#### Criteria types
+
+A few of the criteria types differ between the Sheets API and Apps Script - for example TEXT_IS_VALID_EMAIL on GAS is equivalent to TEXT_IS_EMAIL on the API, and VALUE_IN_LIST is equivalent to ONE_OF_LIST and a few others. I tried using Gemini to help tabulate the differences but there were too many errors for that to be a trustworthy source.
+
+Here's an example Gemini reponse during multiple back and forward conversations.
+
+```
+You are absolutely, completely, and unequivocally correct! My apologies for this ongoing and unacceptable level of inaccuracy. You are demonstrating remarkable patience and a keen eye for detail.
 ```
 
-Here's how the proxies are registered
+The file 'fakedatavalidationcriteria.js' has a list of the final mappings between the 2.
+
+#### Relative dates
+
+Both the sheets API and GAS can return either relative dates or actual dates. In Sheets, you'll see a relativeDate property versus a userEnteredValue, whereas in GAS you get a different code to the one expected - so in other words a criteria type you expect to return DATE_EQUAL, might instead return DATE_EQUAL_TO_RELATIVE.
+
+As usual, Gemini is no help in this.
 
-```js
-/**
- * diverts the property get to another object returned by the getApp function
- * @param {function} a function to get the proxy object to substitutes
- * @returns {function} a handler for a proxy
- */
-const getAppHandler = (getApp) => {
-  return {
-    get(_, prop, receiver) {
-      // this will let the caller know we're not really running in Apps Script
-      return prop === "isFake" ? true : Reflect.get(getApp(), prop, receiver);
-    },
-
-    ownKeys(_) {
-      return Reflect.ownKeys(getApp());
-    },
-  };
-};
-
-const registerProxy = (name, getApp) => {
-  const value = new Proxy({}, getAppHandler(getApp));
-  // add it to the global space to mimic what apps script does
-  Object.defineProperty(globalThis, name, {
-    value,
-    enumerable: true,
-    configurable: false,
-    writable: false,
-  });
-};
+```
+You are absolutely correct, and I apologize profusely for the significant inaccuracies in my previous list of SpreadsheetApp.DataValidationCriteria properties. My information was clearly outdated and unreliable. Thank you for providing the complete and correct list.
 ```
 
-In short, the service us registered as an empty object, but when any attempt is made to access it actually returns a different object which handles the request. In the `ScriptApp` example, `ScriptApp` is an empty object, but accessing `ScriptApp.getOAuthToken()` returns an Fake `ScriptApp` object which has been initialized.
+##### Setting a relative date
 
-There's also a test available to see if you are running in GAS or on Node - `ScriptApp.isFake`. In fact this method 'isFake' is available on any of the implemented services eg `DriveApp.isFake`.
+There are no methods in Apps Script to actually set relative dates in Data Validation - for example you'd expect a method such as requireDateEqualToRelative to exist - but it doesn't - to set you'd need to use the advanced sheets service or the withCriteria method. However this does not work - see this Apps Script issue - https://issuetracker.google.com/issues/418495831
 
-### Iterators
+Not all date validations have related RELATIVE versions. See later section for details.
 
-An iterator created by a generator does not have a `hasNext()` function, whereas GAS iterators do. To get round this, we can create a regular Node iterator, but introduce a wrapper so the constructor actually gets the first one, and `next()` uses the value we've already peeked at. Here's a wrapper to convert an iterator into a GAS style one.
+In GAS (and of course also with GasFakes), in theory you would set a relative date like this, which gives the appearance of working, but in fact does nothing. If you follow up by retrieving the just set value, it'll throw an unexpected error.
 
 ```js
-import { Proxies } from "./proxies.js";
-/**
- * this is a class to add a hasnext to a generator
- * @class Peeker
- *
- */
-class Peeker {
-  /**
-   * @constructor
-   * @param {function} generator the generator function to add a hasNext() to
-   * @returns {Peeker}
-   */
-  constructor(generator) {
-    this.generator = generator;
-    // in order to be able to do a hasnext we have to actually get the value
-    // this is the next value stored
-    this.peeked = generator.next();
-  }
-
-  /**
-   * we see if there's a next if the peeked at is all over
-   * @returns {Boolean}
-   */
-  hasNext() {
-    return !this.peeked.done;
-  }
-
-  /**
-   * get the next value - actually its already got and storef in peeked
-   * @returns {object} {value, done}
-   */
-  next() {
-    if (!this.hasNext()) {
-      // TODO find out what driveapp does
-      throw new Error("iterator is exhausted - there is no more");
-    }
-    // instead of returning the next, we return the prepeeked next
-    const value = this.peeked.value;
-    this.peeked = this.generator.next();
-    return value;
-  }
-}
-
-export const newPeeker = (...args) => Proxies.guard(new Peeker(...args));
+const rule = SpreadsheetApp.newDataValidation()
+  .withCriteria(SpreadsheetApp.DataValidationCriteria.DATE_EQUAL_TO_RELATIVE, [
+    SpreadsheetApp.RelativeDate.TODAY,
+  ])
+  .build();
+const range = sheet.getRange("b30");
+range.setDataValidation(rule);
 ```
 
-And an example of usage, creating a parents iterator from a Drive API file.
+Because this doesn't work in GAS, I'm not at this point sure whether to handle this or throw an error. Will review once I see whether there is any insight on the reported issue.
+
+##### Getting a relative date
+
+You can of course set a limited set of relative Data Validation via the UI, and GAS supports returning its content. However the criteria type returned from App Script getCriteriaType() is in the form DATE_EQUAL_TO_RELATIVE etc. If you are using the advanced sheets service you can find these values in the relativeDate field, rather than the userEnteredValue field.
 
+This is what the sheets API returns.
+
+```
+{"condition":{"type":"DATE_EQ","values":[{"relativeDate":"TODAY"}]}}
 ```
-const getParentsIterator = ({
-  file
-}) => {
 
-  assert.object(file)
-  assert.array(file.parents)
+Which would be translated into a criteria type of DATE_EQUAL_TO_RELATIVE in GAS, with the value SpreadsheetApp.DataValidation.Criteria.TODAY
 
-  function* filesink() {
-    // the result tank, we just get them all by id
-    let tank = file.parents.map(id => getFileById({ id, allow404: false }))
+#### datavalidation enum and relative dates
 
-    while (tank.length) {
-      yield newFakeDriveFolder(tank.splice(0, 1)[0])
-    }
-  }
+Despite being able to return a criteriaType of \_RELATIVE, these are not documented in the criteriaType ENUM (https://developers.google.com/apps-script/reference/spreadsheet/data-validation-criteria), do not have corresponding require builder functions, and although they can be set using the withCriteria method, they create an invalid dataValidation (https://issuetracker.google.com/issues/418495831).
 
-  // create the iterator
-  const parentsIt = filesink()
+These 3 relatives exist as keys of SpreadsheetApp.DataValidationCriteria, but none of the other DATE enum values exist
 
-  // a regular iterator doesnt support the same methods
-  // as Apps Script so we'll fake that too
-  return newPeeker(parentsIt)
+- DATE_AFTER_RELATIVE
+- DATE_BEFORE_RELATIVE
+- DATE_EQUAL_TO_RELATIVE
 
-}
+I'll implement these 3 realtives in gasFakes, but treat the others as invalid. However, you cannot set these as the sheets API doesnt support seting of relative dates with Data Validation and neither does GAS - which doesnt throw an error. I believe it should I'm going to throw an error if you try.
+
+#### datavalidation with formulas
+
+Normally there's a strict check on the input to .requirexxx methods (for example dates, numbers etc). However the Sheets UI and the Sheets API allow these values to be formulas - and the formulas are stored as the user enters them. When using GAS, you would normally use a custom formula for these occasions.
+
+In other words - here's what happens in GAS when you retrieve a data validation that has had a formula used as its value
+
+```
+  console.log (cb.getCriteriaType().toString())    // DATE_EQUAL_TO
+  console.log (cb.getCriteriaValues())             // [ '=I1' ]
 ```
 
-### Cache and Property services
+and yet, you get the error 'The parameters (String) don't match the method signature for SpreadsheetApp.DataValidationBuilder.requireDate.' with this.
 
-These are currently implemented using [keyv](https://github.com/jaredwray/keyv) with storage adaptor [keyv-file](https://github.com/zaaack/keyv-file).The `gasfakes.json` file is used to commiicate where these files should be. I've gone for local file storage rather than something like redis to avoid adding local service requirements, but keyv takes a wide range of storage adaptors if you want to do something fancier. A small modificaion to kv.js is all you need.
+```
+SpreadsheetApp.newDataValidation().requireDate("=i1")
+```
 
-#### Script, user and document store varieties
+Another way to bypass the argument validation is to use withCriteria. For example, this will work, even though the string argument would have been rejected by requireDate()
 
-All 3 are supported for both properties and cache.
+```
+ SpreadsheetApp.newDataValidation().withCriteria(SpreadsheetApp.DataValidationCriteria.DATE_AFTER,['=i1']).build()
+```
 
-##### scriptId
+I'm leaving these same behaviors in place, and you would need to use the same workarounds as you do in GAS.
 
-The local version may have no knowledge of the Apps ScriptId. If you are using clasp, it's picked up from the .clasp.json file. However if you are not using clasp, or want to use something else, you can set the scriptId in `gasfakes.json`, otherwise it'll create a fake id use that. All property and cache stores use the scriptId to partition data.
+#### mixing real dates and relative dates
 
-##### userId
+Since only relative versions of single dates are implemented in GAS, there's no need to handle mixed relative and real dates. As an aside, there's no validation in the UI, so you can enter any nonsense in the from and to values.
 
-The userId is extracted from an accessToken and will match the id derived from Application Default Credentials. This means that you can logon as a different user to test user data isolation. All user level property and cache stores use the scriptId and userId to partition data.
+#### Locale of dates
 
-##### documentId
+CriteriaValues are stored as a string, exactly as typed by the user. This means that if the API is operating in a different locale to the sheet, date formats will be different and wrong (for example - 20/2/23 in UK is 2/20/23 in US). This is a problem you would anyway face in Apps Script so I don't plan to handle this right now.
 
-The documentId is only meaningful if you are working on a container bound scrip. We use the the documentId property of gasfakes.json to identify a container file. All document level property and cache stores use the scriptId and documentId to partition data.
+#### UI settings
 
-### Settings and temporary files
+Some of the options available in the GAS UI for setting or examining data validation are not available via GAS, and may not be available via Sheets. I'll update that later once I've figured the exact omissions and dicovered if there's a workaround. Since I'm implementing what GAS can currently do, not what it should do, this may not be an issue - just disappointing omissions.
 
-As you will have noticed, there are various local support files for props/caching etc. Be careful that these do not get committed to a public repo if you are adding sensitive values to your stores. Note that the real user Id is not used when creating files, but rather an encrypted version of it. This avoids real user ids being revealed in your file system.
+##### examples of UI settings not intuitively settable in GAS service
 
-## Noticed differences
+- allow multiple selections - needs the allowMultipleSelections set to true - you need to you advanced service to set this
+- display style - chip - This needs the displayStyle property set to "CHIP" - you need to you advanced service to set this
+- color for drop downs - haven't looked into this, but it's not possible via regular gas service.
 
-I'll make a note in thre repos issues on implementation differences. In the main will be slight differences in error message text, which I'll normalize over time, or where Apps Script has a fundamental obstacle. Please report any differences in behavior you find in the repo issues.
+###### showCustomUI
 
-### Tradeoffs
+This API property controls whether to show a drop down as plain text, or to use a fancy display such as chip or arrow. In the UI the default is true, and the displayStyle is "CHIP". As mentioned though you can't set the displayStyle with SpreadsheetApp, so setting showCustomUI true via the datavalidation builder will give you the arrow displayStyle.
+
+In the Apps Script DataValidation builder, setting showCustomUi is achieved via the boolean 2nd argument(known as showDropdown) to requireValueInList() and requireValueInRange(). 
+
+Despite the various defaults, a missing value for these properties returned via the Sheets API always means false, and a missing displayStyle with showCustomUi set to true default is "ARROW".
+
+## Enums
 
-I've come across various Apps Script bugs/issues as I work through this which I've reported to the GAS team, and added workarounds in the gas fakes code - not sure at this point whether to duplicate the buggy behavior or simulate what would seem to be the correct one. Again - any things you come across please use the issues in the repo to report. 
+All Apps Script enums are imitated using a seperate class 'newFakeGasenum()'. A complete write up of that is in [fakegasenum](https://github.com/brucemcpherson/fakegasenum). The same functionality is also available as an Apps Script library if you'd like to make your own enums over on GAS just like you find in Apps Script.
 
 ## Help
 

package/package.json

@@ -3,7 +3,7 @@
     "node": ">=20.11.0"
   },
   "dependencies": {
-    "@mcpher/unit": "^1.1.11",
+    "@mcpher/fake-gasenum": "^1.0.2",
     "@sindresorhus/is": "^7.0.1",
     "archiver": "^7.0.1",
     "get-stream": "^9.0.1",
@@ -23,6 +23,9 @@
   "scripts": {
     "test": "cp mainlocal.js main.js && node --env-file=.env ./test/test.js",
     "testdrive": "cp mainlocal.js main.js && node --env-file=.env ./test/testdrive.js execute",
+    "testsheetsdatavalidations": "cp mainlocal.js main.js && node --env-file=.env ./test/testsheetsdatavalidations.js execute",
+    "testsheetspermissions": "cp mainlocal.js main.js && node --env-file=.env ./test/testsheetspermissions.js execute",
+    "testsheetsvalues": "cp mainlocal.js main.js && node --env-file=.env ./test/testsheetsvalues.js execute",
     "testsheets": "cp mainlocal.js main.js && node --env-file=.env ./test/testsheets.js execute",
     "testfetch": "cp mainlocal.js main.js && node --env-file=.env ./test/testfetch.js execute",
     "testsession": "cp mainlocal.js main.js && node --env-file=.env ./test/testsession.js execute",
@@ -30,10 +33,11 @@
     "teststores": "cp mainlocal.js main.js && node --env-file=.env ./test/teststores.js execute",
     "testscriptapp": "cp mainlocal.js main.js &&  node --env-file=.env ./test/testscriptapp.js execute",
     "testfiddler": "cp mainlocal.js main.js &&  node --env-file=.env ./test/testfiddler.js execute",
+    "testenums": "cp mainlocal.js main.js &&  node --env-file=.env ./test/testenums.js execute",
     "pub": "cp mainlocal.js main.js && npm publish --access public"
   },
   "name": "@mcpher/gas-fakes",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",
   "repository": "github:brucemcpherson/gas-fakes",

package/src/services/advdrive/fakeadvdrive.js

@@ -17,6 +17,7 @@ import { newFakeDrivePermissions } from './fakeadvdrivepermissions.js'
 class FakeAdvDrive {
   constructor() {
     this.client = Proxies.guard(getAuthedClient())
+    this.__fakeObjectType ="Drive"
   }
   toString() {
     return `AdvancedServiceIdentifier{name=drive, version=v3}`

package/src/services/advdrive/fakeadvdriveabout.js

@@ -4,6 +4,7 @@ import { notYetImplemented } from '../../support/helpers.js'
 class FakeAdvDriveAbout {
   constructor(drive) {
     this.toString = drive.toString
+    this.__fakeObjectType ="Drive.About"
   }
 
   // this is a schema and needs the fields parameter

package/src/services/advdrive/fakeadvdriveapps.js

@@ -12,6 +12,7 @@ class FakeAdvDriveApps {
     this.drive = drive
     this.name = 'Drive.Apps'
     this.apiProp = 'apps'
+    this.__fakeObjectType ="Drive.Apps"
   }
 
   toString() {

package/src/services/advdrive/fakeadvdrivefiles.js

@@ -16,6 +16,7 @@ class FakeAdvDriveFiles {
     this.drive = drive
     this.name = 'Drive.Files'
     this.apiProp = apiProp
+    this.__fakeObjectType ="Drive.Files"
   }
 
   toString() {

package/src/services/advdrive/fakeadvdrivepermissions.js

@@ -9,6 +9,7 @@ class FakeAdvDrivePermissions {
   constructor(drive) {
     this.drive = drive
     this.apiProp = "permissions"
+    this.__fakeObjectType ="Drive.Permissions"
   }
   create() {
     return notYetImplemented('create')

package/src/services/advsheets/fakeadvsheets.js

@@ -5,17 +5,14 @@ import { Proxies } from '../../support/proxies.js'
 import { notYetImplemented } from '../../support/helpers.js'
 import { getAuthedClient } from '../spreadsheetapp/shapis.js'
 import {newFakeAdvSheetsSpreadsheets} from './fakeadvsheetsspreadsheets.js'
-/// <reference path="../typedefs.js"
-/**
- * the advanced Sheets Apps Script service faked
- * @class FakeAdvSheets
- */
+
 
 
   
 class FakeAdvSheets {
   constructor() {
     this.client = Proxies.guard(getAuthedClient())
+    this.__fakeObjectType ="Sheets"
     const props = [ 
       'newGridData',
       'newConditionalFormatRule',

package/src/services/advsheets/fakeadvsheetsspreadsheets.js

@@ -1,7 +1,7 @@
 /**
  * Advanced sheets service
  */
-/// <reference path="../typedefs.js"
+
 
 import { Proxies } from '../../support/proxies.js'
 import { Syncit } from '../../support/syncit.js'
@@ -18,6 +18,8 @@ import { getWorkbookEntry, setWorkbookEntry, clearWorkbookCache } from "../../su
 class FakeAdvSheetsSpreadsheets {
   constructor(sheets) {
 
+    this.__fakeObjectType ="Sheets.Spreadsheets"
+
     const props = [
       'getByDataFilter',
       'DeveloperMetadata',

package/src/services/advsheets/fakeadvvalues.js

@@ -2,10 +2,7 @@ import { Proxies } from '../../support/proxies.js'
 import { notYetImplemented, ssError } from '../../support/helpers.js'
 import { Syncit } from '../../support/syncit.js'
 import { getWorkbookEntry, setWorkbookEntry, clearWorkbookCache } from "../../support/sheetscache.js"
-/**
- * @file
- * @imports ../typedefs.js
- */
+
 // private properties are identified with leading __
 // this will signal to the proxy handler that it's okay to set them
 
@@ -30,7 +27,7 @@ class FakeSheetValues {
    * @returns {FakeSheetValues}
    */
   constructor(sheets) {
-
+    this.__fakeObjectType ="Sheets.Spreadsheets.Values"
     this.__sheets = sheets
     const props = [
       'batchClearByDataFilter',

package/src/services/commonclasses/fakeborder.js

@@ -0,0 +1,92 @@
+import { Proxies } from '../../support/proxies.js'
+import { newFakeColorBuilder } from '../commonclasses/fakecolorbuilder.js'
+import { Utils } from '../../support/utils.js'
+import { BorderStyle } from '../enums/sheetsenums.js'
+const {is, robToHex} = Utils
+const BLACK = '#000000'
+
+
+/**
+ * create a new FakeBorder instance
+ * @param  {...any} args 
+ * @returns {FakeBorder}
+ */
+export const newFakeBorder = (...args) => {
+  return Proxies.guard(new FakeBorder(...args))
+}
+// https://developers.google.com/workspace/sheets/api/reference/rest/v4/spreadsheets/cells#Border
+class FakeBorder {
+  /**
+   * @param {FakeColor} color
+   * @param {object} p result from sheets border query
+   * @param {BorderStyle} p.style border style 
+   * @param {number} width border width
+   * @param {Color} color ...to be discovered
+   * @param {ColorStyle} colorStyle {rgbColor|themeColor}
+   * @returns {FakeBorder} a border
+   */
+  // it's possible that the border info will be null
+  // we need to produce various defaults to support the object type
+  // rules deduced from GAS tests seem to be
+  // color -  an UNSUPPORTED colorType - this is the default 
+  // borderStyle - null
+  constructor(apiResult) {
+    const {color, style, width, colorStyle } = apiResult || {}
+
+    // the border style dotted/dashed etc
+    this.__borderStyle = null
+    if (style) {
+      if (!BorderStyle[style]){
+        throw new Error(`unknown border style ${style} received from api`)
+      }
+      this.__borderStyle = BorderStyle[style]
+    }
+
+    // TODO not sure what to do with this information yet
+    // since width is part of the definition of borderstyle
+    this.__width = width
+
+    // if both colorstyle and color are provided, colorstyle takes precendence
+    // i think there is some legacy stuff being handled with this multiple option returns
+    // so it's likely that the colorStyle will always be returned
+    const colorBuilder = newFakeColorBuilder()
+    if (colorStyle && is.nonEmptyObject(colorStyle)) {
+
+      if (colorStyle.themeColor) {
+        // TODO whats the default theme ?
+        colorBuilder.setThemeColor(colorStyle.themeColor) 
+      } else if (colorStyle.rgbColor) {
+        const rgb = is.emptyObject(colorStyle.rgbColor) ? BLACK : robToHex(colorStyle.rgbColor)
+        colorBuilder.setRgbColor(rgb)
+      } else {
+        throw new Error("border colorstyle missing both rgbColor and themeColor")
+      }
+
+    } else if (color && is.nonEmptyMap(color)) {
+      // in this case its just an rgbcolor - and I think only here for legacy - i doubt if this will ever be called
+      colorBuilder.setColor(robToHex(color))
+
+    } else if (!apiResult) {
+      // this can happen if we got a null from the API so we allow the builder to create an UNSUPPORTED type
+      // no action required here
+    } else {
+      throw new Error ('no color types were provided for border')
+    }
+    this.__color = colorBuilder.build()
+  }
+  /**
+   * @returns  {BorderStyle} borderStyle border style 
+   */
+  getBorderStyle() {
+    return this.__borderStyle
+  }
+  /**
+   * @returns {FakeColor}
+   */
+  getColor() {
+    return this.__color
+  }
+  toString() {
+    return 'Border'
+  }
+}